@maudecode/talaria-web 1.17.2 → 1.19.0

package/sidecar/talaria_sidecar/dependency_sync.py

@@ -0,0 +1,85 @@
+"""Own an Agent sync process tree until completion or the sidecar's stdin pipe closes.
+
+This small supervisor survives a killed sidecar long enough to stop and reap the
+writer. Its OS lock prevents a replacement sidecar from starting another writer
+before that cleanup finishes. Only stdlib imports, even with broken Agent deps.
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import threading
+
+
+def _lock(file) -> None:
+    if os.name == "nt":
+        import msvcrt
+        file.seek(0)
+        if not file.read(1):
+            file.write(b"0")
+            file.flush()
+        file.seek(0)
+        msvcrt.locking(file.fileno(), msvcrt.LK_NBLCK, 1)
+    else:
+        import fcntl
+        fcntl.flock(file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+
+def _stop_tree(child: subprocess.Popen) -> None:
+    if os.name == "nt":
+        # taskkill is part of Windows and terminates the descendants as well.
+        subprocess.run(["taskkill", "/PID", str(child.pid), "/T", "/F"],
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
+    else:
+        try:
+            os.killpg(child.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+    child.wait()
+
+
+def main() -> int:
+    root = Path(sys.argv[1]).resolve()
+    stopped = threading.Event()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        signal.signal(sig, lambda *_: stopped.set())
+
+    def owner_exited() -> None:
+        try:
+            os.read(0, 1)
+        finally:
+            stopped.set()
+
+    threading.Thread(target=owner_exited, daemon=True).start()
+    lock_path = Path(os.environ["HERMES_HOME"]) / ".talaria-agent-sync" / hashlib.sha256(os.fsencode(root)).hexdigest()
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+b") as lease:
+        try:
+            _lock(lease)
+        except OSError:
+            print("Another Agent dependency sync is still running.", file=sys.stderr)
+            return 1
+        if stopped.is_set():
+            return 1
+        child = subprocess.Popen(
+            [sys.executable, "-m", "hermes_cli.venv_sync", "--project-root", str(root), "--json"],
+            cwd=root, stdin=subprocess.DEVNULL, start_new_session=os.name != "nt",
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if os.name == "nt" else 0,
+        )
+        try:
+            while child.poll() is None:
+                if stopped.wait(0.05):
+                    _stop_tree(child)
+                    return 1
+            return child.returncode
+        finally:
+            if child.poll() is None:
+                _stop_tree(child)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/sidecar/talaria_sidecar/home.py

@@ -42,7 +42,22 @@ _RECOVERED_HOMES: set[str] = set()
 _RECOVERY_WARNED: set[str] = set()
 _LAUNCH_ENV_LOCK = threading.Lock()
 _LAUNCH_ENV: dict[str, str] | None = None
-_PROCESS_HOME = Path(os.environ.get("HERMES_HOME") or Path.home() / ".hermes").expanduser()
+
+
+def _process_home() -> Path:
+    explicit = os.environ.get("HERMES_HOME", "")
+    if explicit:
+        return Path(explicit).expanduser()
+    # Match Agent's literal suffix without importing Agent during sidecar startup.
+    suffix = os.environ.get("HERMES_DATA_DIR_SUFFIX", "")
+    if sys.platform == "win32":
+        local_appdata = os.environ.get("LOCALAPPDATA", "").strip()
+        base = Path(local_appdata) if local_appdata else Path.home() / "AppData" / "Local"
+        return base / ("hermes" + suffix)
+    return Path.home() / (".hermes" + suffix)
+
+
+_PROCESS_HOME = _process_home()
 
 
 def _is_named_profile(home: Path) -> bool:
@@ -87,6 +102,11 @@ def _activate_multi_profile_hosting() -> None:
     set_multiplex_active(True)
 
 
+def _launch_terminal_env() -> dict[str, str]:
+    """Agent 0.21.3 twin of ``tui_gateway.launch_profile_policy.launch_terminal_env``."""
+    return {k: v for k, v in _frozen_launch_env().items() if k.startswith("TERMINAL_")}
+
+
 def _launch_secret_scope(home: Path) -> dict[str, str]:
     """Agent 0.21.3 twin of ``tui_gateway.launch_profile_policy.launch_secret_scope``."""
     from agent.secret_scope import _is_global_env, build_profile_secret_scope, is_multiplex_active
@@ -120,6 +140,13 @@ def _secret_scope(home: Path):
         return
     if named:
         activate_multi_profile_hosting()
+        # Plugin managers are per home: load this profile's plugins so the secret sources they register exist.
+        try:
+            from hermes_cli.plugins import discover_plugins
+
+            discover_plugins()
+        except Exception:  # noqa: BLE001 - a broken plugin must not block the call, as in the Agent's own discovery
+            log.debug("Plugin discovery failed for %s", home, exc_info=True)
         hydrate_profile_secret_sources(home)
         secrets = build_profile_secret_scope(home)
     else:
@@ -150,10 +177,13 @@ def _terminal_scope(home: Path):
     else:
         try:
             from agent.secret_scope import is_multiplex_active
-            from tui_gateway.launch_profile_policy import launch_terminal_env
-        except ImportError:  # Agent 0.21.3 cannot layer the launch env, so the launch profile keeps the process env
+        except ImportError:  # An Agent without multiplexing cannot layer the launch env, so the launch profile keeps the process env
             yield
             return
+        try:
+            from tui_gateway.launch_profile_policy import launch_terminal_env
+        except ImportError:  # Agent 0.21.3: the sidecar's twin of the launch-profile policy
+            launch_terminal_env = _launch_terminal_env
         # Like the launch secret scope: the live process env until multiplexing freezes it.
         launch = launch_terminal_env() if is_multiplex_active() else {k: v for k, v in os.environ.items() if k.startswith("TERMINAL_")}
         token = install_profile_terminal_scope(home, env_overlay=launch)
@@ -190,6 +220,9 @@ def _recover_processes(home: Path) -> None:
             if checkpoint.exists() and not isinstance(json.loads(checkpoint.read_text(encoding="utf-8")), list):
                 raise ValueError(f"{checkpoint} is not a list")
             recovered = registry_module.process_registry.recover_from_checkpoint()
+            from .methods.process import track_recovered
+
+            track_recovered(registry_module.process_registry)
         except Exception as exc:  # noqa: BLE001
             # Retried on every call in the home; reported once per home so a lasting failure does not flood the log.
             log.log(logging.DEBUG if key in _RECOVERY_WARNED else logging.WARNING, "Background process recovery failed for %s", home, exc_info=True)
@@ -229,3 +262,23 @@ def scoped_home(home: Path):
                 os.environ.pop("HERMES_HOME", None)
             else:
                 os.environ["HERMES_HOME"] = previous
+
+
+@contextlib.contextmanager
+def session_workspace(workspace: str | None):
+    """Bind the session's declared workspace (the Agent's ``_SESSION_CWD``), so terminals, AGENTS.md discovery and goal
+    gates run there instead of the sidecar's launch directory. No workspace keeps the Agent's own resolution. A context
+    variable, so concurrent calls never share it; a missing Agent surface is logged, not fatal."""
+    try:
+        from agent.runtime_cwd import _SESSION_CWD
+    except Exception:  # noqa: BLE001
+        log.debug("session cwd bind unavailable", exc_info=True)
+        _SESSION_CWD = None
+    if not workspace or _SESSION_CWD is None:
+        yield
+        return
+    token = _SESSION_CWD.set(str(workspace))
+    try:
+        yield
+    finally:
+        _SESSION_CWD.reset(token)

package/sidecar/talaria_sidecar/methods/__init__.py

@@ -29,9 +29,9 @@ class Registry:
 
 def build_methods(runtime: AgentRuntime) -> dict[str, Handler]:
     registry = Registry(runtime)
-    from . import aux, chat, commands, config, cron, gateway, goals, kanban, mcp, oauth, process, profiles, providers, skills, state_db, stt, text, usage, worktree  # noqa: WPS433
+    from . import aux, chat, checkpoints, commands, config, connectors, cron, gateway, goals, kanban, mcp, memory, oauth, process, profiles, providers, skills, state_db, stt, text, toolsets, usage, worktree, write_approval  # noqa: WPS433
     from . import runtime as runtime_methods
 
-    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, aux, text, process, usage, gateway, worktree, chat, config):
+    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, aux, text, process, usage, gateway, worktree, checkpoints, memory, chat, config, toolsets, write_approval, connectors):
         module.register(registry)
     return registry.methods

package/sidecar/talaria_sidecar/methods/aux.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import contextlib
+import contextvars
+import inspect
 import logging
 import threading
 import uuid
@@ -69,14 +71,44 @@ def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
                 close()
             except Exception:  # noqa: BLE001
                 log.debug("%s fallback agent close failed", task, exc_info=True)
-    return {"model": str(runtime.get("model") or ""), "text": str((result or {}).get("final_response") or "").strip(), "usage": None}
+    return {"model": str(runtime.get("model") or ""), "text": str((result or {}).get("final_response") or "").strip(), "usage": None, "finish_reason": None}
 
 
-def complete(task: str, messages: list, *, main_runtime: dict | None, max_tokens: int | None, temperature: float | None, ctx: CallContext, main_fallback: bool = False) -> dict:
+def _model_completion(task: str, messages: list, *, model: str, provider: str | None, max_tokens: int | None, temperature: float | None, ctx: CallContext) -> dict:
+    """TAL-258 (predecessor ``_agent_text_completion``): the named model answers itself through the Agent's ``call_llm``,
+    reasoning off and no tools, so the caller sees its ``finish_reason``. ``max_tokens`` reaches the provider on the routes
+    the Agent forwards a cap on. ``credential_missing`` when the model has no credential."""
+    from .chat import _resolve_runtime
+
+    runtime = _resolve_runtime(provider, model)
+    if not runtime.get("api_key"):
+        raise RpcError(f"no credential for model {model or 'default'!r}", condition="credential_missing")
+    resolved = model or str(runtime.get("model") or "")
+    response = _call_llm(
+        task, ctx, provider=provider or runtime.get("provider"), model=resolved, base_url=runtime.get("base_url"), api_key=runtime.get("api_key"),
+        api_mode=runtime.get("api_mode"), messages=messages, max_tokens=int(max_tokens) if max_tokens else None,
+        temperature=float(temperature) if temperature is not None else None, reasoning_config={"enabled": False}, timeout=30.0,
+    )
+    return _response_result(resolved, response)
+
+
+def _response_result(model: str, response) -> dict:
+    """The ``aux.complete`` result for one complete (non-streamed) chat response; a response without a choice raises."""
+    choice = response.choices[0]
+    reason = getattr(choice, "finish_reason", None)
+    return {"model": str(model), "text": str(choice.message.content or "").strip(), "usage": _usage_dict(getattr(response, "usage", None)),
+            "finish_reason": str(reason) if reason else None}
+
+
+def complete(task: str, messages: list, *, main_runtime: dict | None, max_tokens: int | None, temperature: float | None, ctx: CallContext, main_fallback: bool = False,
+             model: str | None = None, provider: str | None = None) -> dict:
     """One auxiliary completion; streams ``token`` frames when the client supports it.
 
     With ``main_fallback`` the main model answers (through ``AIAgent``) when no auxiliary client is configured or the
-    auxiliary call fails, as the predecessor's git commit-message route did."""
+    auxiliary call fails, as the predecessor's git commit-message route did. An explicit ``model`` skips the auxiliary
+    route: that model answers (``_model_completion``)."""
+    if model is not None:
+        return _model_completion(task, messages, model=model, provider=provider, max_tokens=max_tokens, temperature=temperature, ctx=ctx)
     try:
         from agent.auxiliary_client import get_text_auxiliary_client
     except Exception as exc:  # noqa: BLE001
@@ -90,46 +122,116 @@ def complete(task: str, messages: list, *, main_runtime: dict | None, max_tokens
         if main_fallback and main_runtime and main_runtime.get("model"):
             return _main_model_completion(messages, main_runtime, task=task)
         raise RpcError(f"no auxiliary model configured for task {task!r}", condition="aux_unconfigured")
+    create, stream = _aux_request(task, client, model, messages, main_runtime=main_runtime, max_tokens=max_tokens, temperature=temperature, ctx=ctx)
     if main_fallback and main_runtime and main_runtime.get("model"):
         try:
-            return _stream_completion(client, model, messages, max_tokens=max_tokens, temperature=temperature, ctx=ctx)
+            return _stream_completion(create, model, stream=stream, ctx=ctx)
         except RpcError:
             raise
         except Exception as exc:  # noqa: BLE001 - predecessor fell back to the main model
             log.debug("auxiliary %s call failed; falling back to the main model: %s", task, exc)
             return _main_model_completion(messages, main_runtime, task=task)
-    return _stream_completion(client, model, messages, max_tokens=max_tokens, temperature=temperature, ctx=ctx)
+    return _stream_completion(create, model, stream=stream, ctx=ctx)
+
+
+def _permit_limited(task: str) -> bool:
+    """Whether ``auxiliary.<task>.max_concurrency`` limits the task, so the Agent's ``call_llm`` may wait for a permit."""
+    from agent import auxiliary_client
+
+    acquire = getattr(auxiliary_client, "_acquire_sync_aux_semaphore", None)
+    return callable(acquire) and acquire(task) is not None
+
+
+def _call_llm(task: str, ctx: CallContext, **kwargs):
+    """The Agent's ``call_llm``. For a permit-limited task ``call_llm`` waits for the permit uncancellably, so the call
+    runs on a helper thread under the Agent's interrupt protection: a cancelled call returns at once and frees its
+    worker, and the Agent's protected provider call drops the request before dispatch once the permit comes."""
+    from agent import auxiliary_client
+
+    if not _permit_limited(task):
+        return auxiliary_client.call_llm(task, **kwargs)
+    outcome: dict = {}
+    done = threading.Event()
+
+    def run() -> None:
+        try:
+            with auxiliary_client.aux_interrupt_protection(cancel_event=ctx.cancel_event):
+                outcome["response"] = auxiliary_client.call_llm(task, **kwargs)
+        except BaseException as exc:  # noqa: BLE001 - handed to the waiting worker
+            outcome["error"] = exc
+        finally:
+            done.set()
+
+    threading.Thread(target=contextvars.copy_context().run, args=(run,), daemon=True, name=f"aux-{task}").start()
+    while not done.wait(0.25):
+        ctx.check_cancelled()
+    ctx.check_cancelled()
+    if "error" in outcome:
+        raise outcome["error"]
+    return outcome["response"]
 
 
-def _stream_completion(client, model: str, messages: list, *, max_tokens: int | None, temperature: float | None, ctx: CallContext) -> dict:
-    kwargs: dict = {"model": model, "messages": messages}
+def _call_llm_streams() -> bool:
+    """Whether the Agent's ``call_llm`` streams with a caller's main runtime (older Agents cannot)."""
+    try:
+        from agent.auxiliary_client import call_llm
+    except ImportError:
+        return False
+    return {"stream", "main_runtime"} <= inspect.signature(call_llm).parameters.keys()
+
+
+def _aux_request(task: str, client, model: str, messages: list, *, main_runtime: dict | None, max_tokens: int | None, temperature: float | None, ctx: CallContext):
+    """``(create(**stream), stream)`` for one auxiliary request. TAL-823: through the Agent's ``call_llm`` funnel (plugin
+    hooks, a custom provider's ``extra_body``, watchdogs, response unwrap, fallbacks) when it streams; else the raw
+    client. ``stream`` is False for a permit-limited task (its call must stay cancellable, see ``_call_llm``) and for
+    the Agent's Codex, Anthropic and Bedrock shims, which answer ``stream=True`` whole."""
+    kwargs: dict = {"messages": messages}
     if max_tokens:
         kwargs["max_tokens"] = int(max_tokens)
     if temperature is not None:
         kwargs["temperature"] = float(temperature)
+    stream = hasattr(client.chat.completions, "with_streaming_response")
+    if _call_llm_streams():
+        return (lambda **stream: _call_llm(task, ctx, main_runtime=main_runtime, **kwargs, **stream)), stream and not _permit_limited(task)
+    return (lambda **stream: client.chat.completions.create(model=model, **kwargs, **stream)), stream
+
+
+def _stream_completion(create, model: str, *, stream: bool, ctx: CallContext) -> dict:
+    if not stream:
+        return _response_result(model, create())
     text_parts: list[str] = []
     usage = None
+    finish_reason = None
     try:
-        stream = client.chat.completions.create(stream=True, **kwargs)
-        for chunk in stream:
-            ctx.check_cancelled()
-            choices = getattr(chunk, "choices", None) or []
-            delta = getattr(choices[0], "delta", None) if choices else None
-            piece = getattr(delta, "content", None) if delta is not None else None
-            if piece:
-                text_parts.append(piece)
-                ctx.emit("token", {"text": piece})
-            chunk_usage = getattr(chunk, "usage", None)
-            if chunk_usage is not None:
-                usage = _usage_dict(chunk_usage)
+        chunks = create(stream=True)
+        if hasattr(chunks, "choices"):  # the route resolved to a shim that answers ``stream=True`` whole
+            return _response_result(model, chunks)
+        try:
+            for chunk in chunks:
+                ctx.check_cancelled()
+                choices = getattr(chunk, "choices", None) or []
+                delta = getattr(choices[0], "delta", None) if choices else None
+                piece = getattr(delta, "content", None) if delta is not None else None
+                if piece:
+                    text_parts.append(piece)
+                    ctx.emit("token", {"text": piece})
+                if choices and getattr(choices[0], "finish_reason", None):
+                    finish_reason = str(choices[0].finish_reason)
+                chunk_usage = getattr(chunk, "usage", None)
+                if chunk_usage is not None:
+                    usage = _usage_dict(chunk_usage)
+        finally:
+            # Releases the connection and the Agent's per-task concurrency permit on cancel or failure, too.
+            close = getattr(chunks, "close", None)
+            if callable(close):
+                with contextlib.suppress(Exception):
+                    close()
     except RpcError:
         raise
     except Exception as exc:  # noqa: BLE001 - fall back to a non-streaming call
         log.debug("streaming auxiliary call failed (%s); retrying without stream", exc)
-        response = client.chat.completions.create(**kwargs)
-        text_parts = [str(response.choices[0].message.content or "")]
-        usage = _usage_dict(getattr(response, "usage", None))
-    return {"model": str(model), "text": "".join(text_parts).strip(), "usage": usage}
+        return _response_result(model, create())
+    return {"model": str(model), "text": "".join(text_parts).strip(), "usage": usage, "finish_reason": finish_reason}
 
 
 def _usage_dict(usage) -> dict | None:
@@ -143,6 +245,39 @@ def _usage_dict(usage) -> dict | None:
     return out or None
 
 
+def _effort_word(task_cfg: dict) -> str:
+    """Agent ``_aux_effort_word``: the resolved ``reasoning_effort`` ("" = provider default; YAML False = "none")."""
+    raw = task_cfg.get("reasoning_effort")
+    return "none" if raw is False else str(raw or "").strip().lower()
+
+
+def aux_tasks() -> dict:
+    """TAL-800: the home's auxiliary slots in Agent order, the ``hermes model`` picker's built-ins then the home's plugin
+    tasks, each with its resolved reasoning effort and, for a task that inherits another slot, its effective route.
+    ``reserved`` names the Agent's other ``auxiliary.*`` keys (settings and unlisted routes), which are never slots."""
+    from agent.auxiliary_client import _get_auxiliary_task_config
+    from hermes_cli.config import DEFAULT_CONFIG
+    from hermes_cli.main_provider_setup import _AUX_TASKS
+
+    rows = [{"key": key, "label": label, "description": description, "inherit_from": None} for key, label, description in _AUX_TASKS]
+    builtin = {row["key"] for row in rows}
+    try:
+        from hermes_cli.plugins import get_plugin_auxiliary_tasks
+
+        plugin_tasks = [entry for entry in get_plugin_auxiliary_tasks() if entry.get("key") and entry["key"] not in builtin]
+    except Exception:  # noqa: BLE001 - plugin discovery must never hide the built-in slots (the Agent's own rule)
+        log.debug("plugin auxiliary task lookup failed", exc_info=True)
+        plugin_tasks = []
+    rows += [{"key": str(entry["key"]), "label": str(entry.get("display_name") or entry["key"]), "description": str(entry.get("description") or ""),
+              "inherit_from": str(entry.get("inherit_from") or "") or None} for entry in plugin_tasks]
+    for row in rows:
+        resolved = _get_auxiliary_task_config(row["key"])
+        row["reasoning_effort"] = _effort_word(resolved)
+        row["effective"] = {field: str(resolved.get(field) or "") for field in ("provider", "model", "base_url")} if row["inherit_from"] else None
+    listed = {row["key"] for row in rows}
+    return {"tasks": rows, "reserved": sorted(key for key in (DEFAULT_CONFIG.get("auxiliary") or {}) if key not in listed)}
+
+
 def register(registry) -> None:
     @registry.method("aux.complete")
     def complete_(ctx: CallContext, params: dict) -> dict:
@@ -154,7 +289,14 @@ def register(registry) -> None:
             raise InvalidParams("messages must be a non-empty list")
         main_runtime = params.get("main_runtime") if isinstance(params.get("main_runtime"), dict) else None
         with scoped_home(profile_home_param(params)):
-            return complete(task, messages, main_runtime=main_runtime, max_tokens=params.get("max_tokens"), temperature=params.get("temperature"), ctx=ctx, main_fallback=bool(params.get("main_fallback")))
+            model = params.get("model")
+            return complete(task, messages, main_runtime=main_runtime, max_tokens=params.get("max_tokens"), temperature=params.get("temperature"), ctx=ctx, main_fallback=bool(params.get("main_fallback")),
+                            model=str(model).strip() if isinstance(model, str) else None, provider=str(params.get("provider") or "").strip() or None)
+
+    @registry.method("aux.tasks")
+    def tasks(ctx: CallContext, params: dict) -> dict:
+        with scoped_home(profile_home_param(params)):
+            return aux_tasks()
 
     @registry.method("aux.resolve")
     def resolve(ctx: CallContext, params: dict) -> dict: