@maudecode/talaria-web 1.19.0 → 1.20.0

package/sidecar/talaria_sidecar/home.py

@@ -24,6 +24,7 @@ its launch-process ``TERMINAL_*`` under those files.
 from __future__ import annotations
 
 import contextlib
+import copy
 import importlib
 import json
 import logging
@@ -42,6 +43,69 @@ _RECOVERED_HOMES: set[str] = set()
 _RECOVERY_WARNED: set[str] = set()
 _LAUNCH_ENV_LOCK = threading.Lock()
 _LAUNCH_ENV: dict[str, str] | None = None
+_SCOPE_CACHE_LOCK = threading.Lock()
+_SCOPE_CACHE: dict[str, dict] = {}
+_SCOPE_CACHE_MAX = 64
+
+
+def _scope_stamp(home: Path) -> tuple | None:
+    stamps = []
+    for name in (".env", "config.yaml"):
+        try:
+            st = (home / name).stat()
+        except FileNotFoundError:
+            stamps.append(None)
+        except OSError:
+            return None  # Uncertain identity must never reuse credentials or terminal authority.
+        else:
+            stamps.append((st.st_dev, st.st_ino, st.st_mtime_ns, st.st_ctime_ns, st.st_size, st.st_mode))
+    return tuple(stamps)
+
+
+def _cached_scope(home: Path, kind: str, stamp: tuple | None, inputs, build):
+    """One snapshot of each kind per home; bindings receive copies, never the memo itself."""
+    key = str(home.absolute())
+    with _SCOPE_CACHE_LOCK:
+        scopes = _SCOPE_CACHE.pop(key, {})
+        _SCOPE_CACHE[key] = scopes
+        while len(_SCOPE_CACHE) > _SCOPE_CACHE_MAX:
+            del _SCOPE_CACHE[next(iter(_SCOPE_CACHE))]
+        cached = scopes.pop(kind, None)
+        if (
+            stamp is not None
+            and cached is not None
+            and cached[:2] == (stamp, inputs)
+            and _scope_stamp(home) == stamp
+        ):
+            scopes[kind] = cached
+            return copy.deepcopy(cached[2])
+        value = build()
+        # A writer racing the build cannot lend its file identity to stale bytes.
+        if stamp is not None and _scope_stamp(home) == stamp:
+            scopes[kind] = (stamp, copy.deepcopy(inputs), copy.deepcopy(value))
+        return value
+
+
+def _secret_scope_inputs(home: Path, named: bool):
+    """File stamps alone cannot detect vault refreshes, managed policy, or launch-env edits."""
+    try:
+        from hermes_cli.env_loader import get_secret_source_values
+        from hermes_cli.managed_scope import load_managed_env
+        from gateway.config_loader import bridged_allow_all_users
+
+        launch = None
+        if not named:
+            try:
+                from tui_gateway.launch_profile_policy import _launch_env
+            except ImportError:
+                from agent.secret_scope import is_multiplex_active
+
+                launch = _frozen_launch_env() if is_multiplex_active() else dict(os.environ)
+            else:
+                launch = _launch_env()
+        return (get_secret_source_values(home), load_managed_env(), bridged_allow_all_users(), launch)
+    except Exception:  # Older/partial Agents keep the original uncached builder and its policy.
+        return None
 
 
 def _process_home() -> Path:
@@ -118,7 +182,7 @@ def _launch_secret_scope(home: Path) -> dict[str, str]:
 
 
 @contextlib.contextmanager
-def _secret_scope(home: Path):
+def _secret_scope(home: Path, stamp: tuple | None = None, *, load_plugins: bool = True):
     """Install ``home``'s credential scope for the call; named profiles run under multiplex semantics."""
     named = _is_named_profile(home)
     try:
@@ -140,17 +204,18 @@ 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:
-        secrets = launch_secret_scope(home)
+        # Dashboard hosting must never load third-party code into this sidecar.
+        if load_plugins:
+            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)
+    build = lambda: build_profile_secret_scope(home) if named else launch_secret_scope(home)
+    inputs = _secret_scope_inputs(home, named)
+    secrets = build() if inputs is None else _cached_scope(home, "secrets", stamp, inputs, build)
     scope_token = set_secret_scope(secrets)
     try:
         yield
@@ -159,7 +224,7 @@ def _secret_scope(home: Path):
 
 
 @contextlib.contextmanager
-def _terminal_scope(home: Path):
+def _terminal_scope(home: Path, stamp: tuple | None = None):
     """Install ``home``'s terminal policy for the call; a policy file that cannot be read refuses terminal execution."""
     named = _is_named_profile(home)
     try:
@@ -172,9 +237,8 @@ def _terminal_scope(home: Path):
             )
         yield
         return
-    if named:
-        token = install_profile_terminal_scope(home)
-    else:
+    launch = None
+    if not named:
         try:
             from agent.secret_scope import is_multiplex_active
         except ImportError:  # An Agent without multiplexing cannot layer the launch env, so the launch profile keeps the process env
@@ -186,7 +250,19 @@ def _terminal_scope(home: Path):
             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)
+    try:
+        from tools.terminal_scope import build_profile_terminal_scope, set_terminal_scope, TerminalPolicyRefusal, TerminalPolicyUnavailable
+    except ImportError:  # Keep the installed Agent's original behavior when its builder API is absent.
+        token = install_profile_terminal_scope(home, env_overlay=launch) if not named else install_profile_terminal_scope(home)
+    else:
+        try:
+            policy = _cached_scope(
+                home, "terminal", stamp, (launch, str(Path.home())),
+                lambda: build_profile_terminal_scope(home, env_overlay=launch),
+            )
+        except (OSError, TerminalPolicyUnavailable) as exc:
+            policy = TerminalPolicyRefusal(str(exc))
+        token = set_terminal_scope(policy)
     try:
         yield
     finally:
@@ -234,9 +310,10 @@ def _recover_processes(home: Path) -> None:
 
 
 @contextlib.contextmanager
-def scoped_home(home: Path):
+def scoped_home(home: Path, *, load_plugins: bool = True):
     """Run the body with Hermes Agent resolving ``get_hermes_home()`` to ``home``."""
     home = Path(home).expanduser()
+    stamp = _scope_stamp(home)
     try:
         from hermes_constants import reset_hermes_home_override, set_hermes_home_override
     except Exception:  # noqa: BLE001 - older Agent without context-local homes
@@ -244,7 +321,7 @@ def scoped_home(home: Path):
     if set_hermes_home_override is not None:
         token = set_hermes_home_override(home)
         try:
-            with _secret_scope(home), _terminal_scope(home):
+            with _secret_scope(home, stamp, load_plugins=load_plugins), _terminal_scope(home, stamp):
                 _recover_processes(home)
                 yield home
         finally:
@@ -254,7 +331,7 @@ def scoped_home(home: Path):
         previous = os.environ.get("HERMES_HOME")
         os.environ["HERMES_HOME"] = str(home)
         try:
-            with _secret_scope(home), _terminal_scope(home):
+            with _secret_scope(home, stamp, load_plugins=load_plugins), _terminal_scope(home, stamp):
                 _recover_processes(home)
                 yield home
         finally:

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, 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 aux, chat, checkpoints, commands, config, connectors, cron, dashboard_plugins, gateway, goals, kanban, mcp, memory, oauth, plugin_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, checkpoints, memory, chat, config, toolsets, write_approval, connectors):
+    for module in (runtime_methods, goals, commands, kanban, state_db, profiles, skills, mcp, stt, cron, providers, oauth, plugin_oauth, aux, text, process, usage, gateway, worktree, checkpoints, memory, chat, config, toolsets, write_approval, connectors, dashboard_plugins):
         module.register(registry)
     return registry.methods

package/sidecar/talaria_sidecar/methods/aux.py

@@ -41,11 +41,15 @@ def resolve_main_runtime(hint: dict | None) -> dict | None:
     return out
 
 
-def _main_model_completion(messages: list, runtime: dict, *, task: str) -> dict:
+def _main_model_completion(messages: list, runtime: dict, *, task: str, ctx: CallContext) -> dict:
     """Predecessor fallback: run the main model through ``AIAgent`` with no tools when no auxiliary client answers.
 
     The throwaway agent never touches long-term memory (the prompt is a raw git diff) and is always closed."""
-    from .chat import _agent_class, _supported
+    from .chat import _agent_class, _supported, _require_data_use_support
+
+    if _require_data_use_support(messages):
+        # The string-only AIAgent fallback would discard the derived prompt's routing metadata.
+        return _model_completion(task, messages, model=runtime["model"], provider=runtime.get("provider"), max_tokens=None, temperature=None, ctx=ctx)
 
     AIAgent = _agent_class()
 
@@ -78,12 +82,15 @@ def _model_completion(task: str, messages: list, *, model: str, provider: str |
     """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
+    from .chat import _resolve_runtime, _require_data_use_support
 
     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 "")
+    if _require_data_use_support(messages):
+        route = _privacy_request_kwargs(messages, provider=provider or runtime.get("provider"), model=resolved, base_url=runtime.get("base_url"), api_key=runtime.get("api_key"))
+        return _stream_completion(lambda **_: _call_llm(task, ctx, **route, messages=messages, max_tokens=max_tokens, temperature=temperature, stream=True), resolved, stream=True, ctx=ctx, retry_nonstream=False)
     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,
@@ -107,6 +114,9 @@ def complete(task: str, messages: list, *, main_runtime: dict | None, max_tokens
     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. An explicit ``model`` skips the auxiliary
     route: that model answers (``_model_completion``)."""
+    from .chat import _require_data_use_support
+
+    protected = bool(_require_data_use_support(messages))
     if model is not None:
         return _model_completion(task, messages, model=model, provider=provider, max_tokens=max_tokens, temperature=temperature, ctx=ctx)
     try:
@@ -114,24 +124,32 @@ def complete(task: str, messages: list, *, main_runtime: dict | None, max_tokens
     except Exception as exc:  # noqa: BLE001
         raise RpcError(f"auxiliary client unavailable: {exc}", condition="aux_unavailable") from exc
     main_runtime = resolve_main_runtime(main_runtime)
-    try:
-        client, model = get_text_auxiliary_client(task, main_runtime=main_runtime)
-    except TypeError:
-        client, model = get_text_auxiliary_client(task)
+    selected_provider = None
+    if protected:
+        # Snapshot the selected provider with its client; get_text_auxiliary_client's tuple omits the provider.
+        from agent.auxiliary_client import _resolve_task_provider_model, resolve_provider_client
+
+        selected_provider, selected_model, base_url, api_key, api_mode = _resolve_task_provider_model(task)
+        client, model = resolve_provider_client(selected_provider, model=selected_model, explicit_base_url=base_url, explicit_api_key=api_key, api_mode=api_mode, main_runtime=main_runtime)
+    else:
+        try:
+            client, model = get_text_auxiliary_client(task, main_runtime=main_runtime)
+        except TypeError:
+            client, model = get_text_auxiliary_client(task)
     if client is None or not model:
         if main_fallback and main_runtime and main_runtime.get("model"):
-            return _main_model_completion(messages, main_runtime, task=task)
+            return _main_model_completion(messages, main_runtime, task=task, ctx=ctx)
         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)
+    create, stream = _aux_request(task, client, model, messages, main_runtime=main_runtime, max_tokens=max_tokens, temperature=temperature, ctx=ctx, selected_provider=selected_provider)
     if main_fallback and main_runtime and main_runtime.get("model"):
         try:
-            return _stream_completion(create, model, stream=stream, ctx=ctx)
+            return _stream_completion(create, model, stream=stream, ctx=ctx, retry_nonstream=not protected)
         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(create, model, stream=stream, ctx=ctx)
+            return _main_model_completion(messages, main_runtime, task=task, ctx=ctx)
+    return _stream_completion(create, model, stream=stream, ctx=ctx, retry_nonstream=not protected)
 
 
 def _permit_limited(task: str) -> bool:
@@ -180,7 +198,25 @@ def _call_llm_streams() -> bool:
     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):
+def _privacy_request_kwargs(messages: list, *, provider, model, base_url, api_key) -> dict:
+    """Pin a verifiable Agent-owned privacy route; streamed call_llm never takes its implicit provider fallback ladder."""
+    from .chat import _require_data_use_support
+    from providers import get_provider_profile
+
+    requires = _require_data_use_support(messages)
+    try:
+        profile = get_provider_profile(str(provider or ""))
+        body = profile.build_extra_body(model=model, base_url=base_url, data_use=requires) if profile else {}
+        policy = body.get("provider", {})
+        safe = not requires.difference({"no_training", "zero_retention"}) and policy.get("data_collection") == "deny" and ("zero_retention" not in requires or policy.get("zdr") is True)
+    except Exception as exc:  # noqa: BLE001 - unknown policy fails before any provider dispatch
+        raise RpcError("Cannot verify the auxiliary provider's connector privacy policy.", condition="data_policy_denied") from exc
+    if not safe or not provider or not base_url or not api_key or not _call_llm_streams():
+        raise RpcError("The auxiliary provider cannot enforce connector privacy requirements.", condition="data_policy_denied")
+    return {"provider": provider, "model": model, "base_url": str(base_url), "api_key": api_key, "extra_body": {"provider": policy}}
+
+
+def _aux_request(task: str, client, model: str, messages: list, *, main_runtime: dict | None, max_tokens: int | None, temperature: float | None, ctx: CallContext, selected_provider: str | None = None):
     """``(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
@@ -190,13 +226,18 @@ def _aux_request(task: str, client, model: str, messages: list, *, main_runtime:
         kwargs["max_tokens"] = int(max_tokens)
     if temperature is not None:
         kwargs["temperature"] = float(temperature)
+    from .chat import _require_data_use_support
+
+    if _require_data_use_support(messages):
+        route = _privacy_request_kwargs(messages, provider=getattr(client, "_hermes_aux_effective_provider", None) or selected_provider, model=model, base_url=getattr(client, "base_url", None), api_key=getattr(client, "api_key", None))
+        return (lambda **_: _call_llm(task, ctx, **route, **kwargs, stream=True)), True
     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:
+def _stream_completion(create, model: str, *, stream: bool, ctx: CallContext, retry_nonstream: bool = True) -> dict:
     if not stream:
         return _response_result(model, create())
     text_parts: list[str] = []
@@ -229,6 +270,8 @@ def _stream_completion(create, model: str, *, stream: bool, ctx: CallContext) ->
     except RpcError:
         raise
     except Exception as exc:  # noqa: BLE001 - fall back to a non-streaming call
+        if not retry_nonstream:
+            raise
         log.debug("streaming auxiliary call failed (%s); retrying without stream", exc)
         return _response_result(model, create())
     return {"model": str(model), "text": "".join(text_parts).strip(), "usage": usage, "finish_reason": finish_reason}
@@ -251,16 +294,31 @@ def _effort_word(task_cfg: dict) -> str:
     return "none" if raw is False else str(raw or "").strip().lower()
 
 
+def _delegation_row() -> dict | None:
+    """TAL-1273: the picker's subagent (``delegate_task``) row, listed after the auxiliary slots. Its route is the
+    top-level ``delegation`` section, not ``auxiliary.delegation``; None on an Agent whose picker has no such row."""
+    try:
+        from hermes_cli.main_provider_setup import _DELEGATION_TASK_DESC, _DELEGATION_TASK_KEY, _DELEGATION_TASK_NAME, _delegation_cfg_as_task
+    except ImportError:
+        return None
+    from hermes_cli.config import load_config
+
+    return {"key": _DELEGATION_TASK_KEY, "label": _DELEGATION_TASK_NAME, "description": _DELEGATION_TASK_DESC, "inherit_from": None,
+            "reasoning_effort": _effort_word(_delegation_cfg_as_task(load_config())), "effective": None}
+
+
 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.
+    """TAL-800: the home's auxiliary slots in Agent order, the ``hermes model`` picker's built-ins, the home's plugin
+    tasks, then the picker's delegation row (TAL-1273), 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}
+    delegation = _delegation_row()
+    builtin = {row["key"] for row in rows} | ({delegation["key"]} if delegation else set())
     try:
         from hermes_cli.plugins import get_plugin_auxiliary_tasks
 
@@ -274,6 +332,8 @@ def aux_tasks() -> dict:
         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
+    if delegation:
+        rows.append(delegation)
     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)}
 
@@ -288,7 +348,9 @@ def register(registry) -> None:
         if not isinstance(messages, list) or not messages:
             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)):
+        from .chat import agent_scope
+
+        with agent_scope(profile_home_param(params)):
             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)