@maudecode/talaria-web 1.20.0 → 1.22.0

package/sidecar/talaria_sidecar/methods/providers.py

@@ -228,6 +228,18 @@ def _unavailable_plugin(provider_id: str) -> bool:
     return not any(p is profile for _name, p in installed_plugin_profiles())
 
 
+def require_runtime_ownership(requested: str | None) -> None:
+    """A process-wide Agent registry must not lend another home's plugin to this runtime."""
+    if not requested:
+        return
+    try:
+        if not _unavailable_plugin(requested.strip().lower()):
+            return
+    except Exception:  # noqa: BLE001 - an unverified plugin owner cannot authorize execution
+        log.debug("runtime plugin ownership check failed", exc_info=True)
+    raise RpcError("Requested provider is unavailable in this profile", condition="credential_missing")
+
+
 def _agent_knows_provider(name: str) -> bool:
     """Whether the Agent's auth layer can resolve this provider id at all.
 
@@ -323,6 +335,35 @@ def model_ids(provider_id: str, *, force_refresh: bool) -> tuple[list[str], bool
         return [], False
 
 
+def model_allowance_snapshot(provider_id: str, *, force_refresh: bool) -> dict:
+    """Native picker metadata in this call's scoped home; no billing write or second usage poll."""
+    if provider_id != "nous":
+        return {}
+    try:
+        from hermes_cli.inventory import build_model_options_payload, load_picker_context
+        from hermes_cli.model_picker_usage import nous_picker_usage
+    except ImportError:
+        return {"metadata_status": "unsupported"}
+    try:
+        payload = build_model_options_payload(load_picker_context(), refresh=force_refresh)
+        row = next((r for r in payload.get("providers", []) if r.get("slug") == provider_id), {})
+        pending = row.get("pricing_pending") is True or row.get("free_tier_pending") is True
+        plan = row.get("plan_usage")
+        fresh = nous_picker_usage() if isinstance(plan, dict) else None
+        return {
+            "metadata_status": "pending" if pending else "stale" if plan and fresh is None else "current",
+            "plan_usage": plan if isinstance(plan, dict) else None,
+            "usage_levels": {mid: level for mid, level in (row.get("usage_levels") or {}).items()
+                             if isinstance(mid, str) and level in ("free", "low", "medium", "top_tier")},
+            "unavailable_model_ids": [mid for mid in row.get("unavailable_models", []) if isinstance(mid, str)] if not pending else [],
+            "allowance_pending": pending,
+            "free_tier": row.get("free_tier") if isinstance(row.get("free_tier"), bool) else None,
+        }
+    except Exception:  # noqa: BLE001 - unknown entitlement is not unavailability
+        log.debug("native picker allowance unavailable", exc_info=True)
+        return {"metadata_status": "error"}
+
+
 def _requests_local_runtime(requested: str | None) -> bool:
     """Whether a resolution asks for the Agent's managed llama.cpp provider, picked the way the Agent picks it: the
     named provider, else the profile's, else ``HERMES_INFERENCE_PROVIDER``."""
@@ -367,6 +408,7 @@ def local_models() -> dict:
 
 
 def resolve_runtime(*, requested: str | None, api_key: str | None, base_url: str | None, target_model: str | None) -> dict:
+    require_runtime_ownership(requested)
     try:
         from hermes_cli.runtime_provider import format_runtime_provider_error, resolve_runtime_provider
     except Exception as exc:  # noqa: BLE001
@@ -535,6 +577,13 @@ def register(reg) -> None:
         with scoped_home(profile_home_param(params)):
             return {"providers": registry()}
 
+    @reg.method("providers.nous_account")
+    def nous_account_(ctx: CallContext, params: dict) -> dict:
+        from . import nous_account
+        home = profile_home_param(params)
+        with scoped_home(home):
+            return {"nous_account": nous_account.read(home)}
+
     @reg.method("providers.auth_status")
     def auth(ctx: CallContext, params: dict) -> dict:
         with scoped_home(profile_home_param(params)):
@@ -547,7 +596,8 @@ def register(reg) -> None:
             raise InvalidParams("provider is required")
         with scoped_home(profile_home_param(params)):
             ids, fallback = model_ids(provider, force_refresh=bool(params.get("force_refresh", False)))
-            return {"provider": provider, "model_ids": ids, "fallback": fallback}
+            return {"provider": provider, "model_ids": ids, "fallback": fallback,
+                    **model_allowance_snapshot(provider, force_refresh=bool(params.get("force_refresh", False)))}
 
     @reg.method("providers.local_models")
     def local(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/skill_revisions.py

@@ -0,0 +1,177 @@
+"""Read the reviewed Hermetic store without executing its API or migrating legacy data."""
+from contextlib import contextmanager
+from datetime import datetime, timezone
+import difflib
+import hashlib
+import itertools
+import json
+import os
+from pathlib import Path
+import re
+import stat
+
+from ..errors import InvalidParams
+from . import dashboard_plugins
+
+_PIN = 'f7026c949d8831b26910f2ebd3434e8c58cdff89'
+_SOURCES = {
+    '__init__.py': '9dfb815be185965bf06c7c5a0fec401f6f376569d1a6830497502898fffcf01d',
+    'plugin.yaml': 'b4fbd03f70f50d2cc391e530b3e4079ecbe249ab6e5c2e4702d475911327b50e',
+    'dashboard/manifest.json': '466cada1eb3345f6fa7e12a5eaef44f8a19bb02546b9456fa0576d81ff89b6c1',
+    'dashboard/plugin_api.py': '23f1c612559f0086ff5c7da6d3cc8fe0c596a05c6f6eaa89db94c8c4d8c99d1d',
+}
+_NAME = re.compile(r'[A-Za-z0-9][A-Za-z0-9._ -]{0,127}')
+_FILE = re.compile(r'([a-f0-9]{16})-SKILL[.]md')
+_MAX_TEXT = 32 * 1024
+_MAX_REVISIONS = 64
+
+
+@contextmanager
+def _directory(anchor, parts=()):
+    """Hold every traversal no-follow, including the profile's ancestors, through the read."""
+    anchor = Path(anchor).absolute()
+    components = (*anchor.parts[1:], *parts)
+    if any(p in ('', '.', '..') or '/' in p or '\\' in p for p in components):
+        raise ValueError('Invalid history path')
+    fd = os.open(anchor.anchor, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
+    try:
+        for part in components:
+            child = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd)
+            os.close(fd)
+            fd = child
+        yield fd
+    finally:
+        os.close(fd)
+
+
+def _read(fd, name, limit):
+    child = os.open(name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=fd)
+    with os.fdopen(child, 'rb') as file:
+        info = os.fstat(file.fileno())
+        if not stat.S_ISREG(info.st_mode) or info.st_size > limit:
+            raise ValueError('History file is too large or not regular')
+        data = file.read(limit + 1)
+        if len(data) > limit:
+            raise ValueError('History file is too large')
+        return data, info.st_mtime
+
+
+def _timestamp(value):
+    try:
+        date = datetime.fromtimestamp(value, timezone.utc) if type(value) in (int, float) else datetime.fromisoformat(value.replace('Z', '+00:00'))
+        return date.astimezone(timezone.utc).isoformat() if date.tzinfo else None
+    except (TypeError, ValueError, OverflowError, OSError, AttributeError):
+        return None
+
+
+def _result(state, reason=None, **fields):
+    return dict(state=state, reason=reason, backend_revision=None, revisions=[], selected=None,
+                comparison=None, replay_available=False) | fields
+
+
+def _identity(catalog, name):
+    entries = catalog(skip_disabled=True, include_hidden=True)
+    matches = [entry for entry in entries if entry.get('load_name') == name]
+    if len(matches) != 1:
+        return None
+    selected = matches[0]
+    declared = selected.get('name')
+    # Hermetic keys storage by declared name; two catalog copies cannot be attributed safely.
+    if not isinstance(declared, str) or not _NAME.fullmatch(declared) or '..' in declared:
+        return None
+    return selected if len([entry for entry in entries if entry.get('name') == declared]) == 1 else None
+
+
+def inspect_revisions(home, name, revision=None, compare_to=None):
+    from .skills import _skill_helper
+
+    if not isinstance(name, str) or not 0 < len(name) <= 256:
+        raise InvalidParams('Invalid skill identity')
+    if any(v is not None and (not isinstance(v, str) or not re.fullmatch('[a-f0-9]{64}', v)) for v in (revision, compare_to)):
+        raise InvalidParams('Invalid revision identity')
+    if not getattr(os, 'O_NOFOLLOW', 0) or not dashboard_plugins.reviewed_producer(home, 'hermetic', _PIN, _SOURCES):
+        return _result('unavailable', 'backend_unavailable')
+    try:
+        catalog = _skill_helper('skill_catalog')
+        selected = _identity(catalog, name) if catalog else None
+        if selected is None:
+            return _result('unavailable', 'identity_unavailable')
+        declared = selected['name']
+        local = Path(selected['path']).relative_to(home / 'skills')
+        if local.name != 'SKILL.md':
+            raise ValueError('Not a local skill')
+        with _directory(home, ('skills', *local.parts[:-1])) as fd:
+            current, _ = _read(fd, 'SKILL.md', _MAX_TEXT)
+        provenance = {}
+        with _directory(home, ('skills',)) as fd:
+            try:
+                ledger, _ = _read(fd, '.curator_ledger.jsonl', 256 * 1024)
+            except FileNotFoundError:
+                ledger = b''
+        for line in ledger.decode('utf-8').splitlines():
+            row = json.loads(line)
+            if not isinstance(row, dict):
+                raise ValueError('Invalid ledger')
+            if row.get('skill') == declared:
+                after = row.get('after') or []
+                if not isinstance(after, list):
+                    raise ValueError('Invalid ledger provenance')
+                for item in after:
+                    if isinstance(item, dict) and isinstance(item.get('sha256'), str):
+                        actor = row.get('actor')
+                        actor = actor if isinstance(actor, str) and len(actor) <= 80 and not any(ord(c) < 32 for c in actor) else None
+                        provenance[item['sha256']] = (_timestamp(row.get('ts')), actor)
+        try:
+            with _directory(home, ('hermetic', 'skill-versions', declared)) as fd:
+                with os.scandir(fd) as iterator:
+                    files = list(itertools.islice(iterator, _MAX_REVISIONS + 1))
+                if len(files) > _MAX_REVISIONS:
+                    raise ValueError('Too many revisions')
+                rows = []
+                for file in files:
+                    match = _FILE.fullmatch(file.name)
+                    if not match:
+                        continue
+                    data, modified = _read(fd, file.name, _MAX_TEXT)
+                    sha = hashlib.sha256(data).hexdigest()
+                    if not sha.startswith(match[1]):
+                        raise ValueError('Revision hash does not match saved bytes')
+                    text = data.decode('utf-8')
+                    if len(text.splitlines()) > 512:
+                        raise ValueError('Too many revision lines')
+                    saved_at, actor = provenance.get(sha, (_timestamp(modified), None))
+                    identity = hashlib.sha256(json.dumps([str(home), name, sha]).encode()).hexdigest()
+                    rows.append(dict(id=identity, sha256=sha, label=sha[:12], saved_at=saved_at, actor=actor,
+                                     current=sha == hashlib.sha256(current).hexdigest(), content=text))
+        except FileNotFoundError:
+            rows = []
+        if not rows:
+            if revision or compare_to:
+                raise InvalidParams('Revision no longer exists; reload history')
+            return _result('missing', 'history_unavailable', backend_revision=_PIN)
+        rows.sort(key=lambda row: (row['saved_at'] or '', row['sha256']), reverse=True)
+        by_id = {row['id']: row for row in rows}
+        target = by_id.get(revision) if revision else rows[0]
+        if target is None:
+            raise InvalidParams('Revision no longer exists; reload history')
+        source = by_id.get(compare_to) if compare_to else next((r for r in rows if r['id'] != target['id']), None)
+        if compare_to and source is None:
+            raise InvalidParams('Revision no longer exists; reload history')
+        comparison = None
+        if source:
+            lines = difflib.unified_diff(source['content'].splitlines(keepends=True), target['content'].splitlines(keepends=True),
+                                        fromfile=source['label'], tofile=target['label'])
+            diff = ''.join(line if line.endswith('\n') else line + '\n\\n' for line in lines)
+            comparison = dict(from_revision=source['id'], to_revision=target['id'], diff=diff)
+        # Native admission can be revoked while filesystem reads are in progress.
+        if not dashboard_plugins.reviewed_producer(home, 'hermetic', _PIN, _SOURCES):
+            return _result('unavailable', 'backend_unavailable')
+        if _identity(catalog, name) != selected:
+            return _result('unavailable', 'identity_unavailable')
+        return dict(state='available', reason=None, backend_revision=_PIN,
+                    revisions=[{k: v for k, v in row.items() if k != 'content'} for row in rows],
+                    selected=dict(revision=target['id'], content=target['content']), comparison=comparison, replay_available=False)
+    except InvalidParams:
+        raise
+    except (ImportError, AttributeError, OSError, ValueError, TypeError, KeyError):
+        return _result('unavailable', 'invalid_history')

package/sidecar/talaria_sidecar/methods/skills.py

@@ -300,6 +300,16 @@ def view_skill(profile_home: Path, name: str) -> dict:
 
 
 def register(registry) -> None:
+    @registry.method("skills.revisions")
+    def revisions(ctx: CallContext, params: dict) -> dict:
+        from .skill_revisions import inspect_revisions
+        home = profile_home_param(params)
+        ctx.check_cancelled()
+        with scoped_home(home, load_plugins=False, recover_processes=False):
+            result = inspect_revisions(home, params.get('name'), params.get('revision'), params.get('compare_to'))
+        ctx.check_cancelled()
+        return result
+
     @registry.method("skills.list")
     def list_(ctx: CallContext, params: dict) -> dict:
         home = profile_home_param(params)

package/sidecar/talaria_sidecar/methods/tts.py

@@ -0,0 +1,67 @@
+"""``tts.synthesize``: bounded audio through the Agent's own speech providers."""
+from __future__ import annotations
+
+import base64
+import json
+import math
+import tempfile
+from pathlib import Path
+
+from ..errors import InvalidParams, RpcError
+from ..home import profile_home_param, scoped_home
+from ..rpc import CallContext
+
+MAX_AUDIO_BYTES = 8 * 1024 * 1024
+
+
+def synthesize(text: str, provider: str, speed: float | None = None) -> dict:
+    from tools import tts_tool
+
+    if (provider != 'edge' and provider not in tts_tool._BUILTIN_DISPATCH
+            and tts_tool._resolve_command_provider_config(provider, tts_tool._load_tts_config()) is None):
+        raise InvalidParams(f'unknown TTS provider {provider}')
+    try:
+        with tempfile.TemporaryDirectory(prefix='talaria-tts-') as directory:
+            root = Path(directory).resolve()
+            result = json.loads(tts_tool.text_to_speech_tool(
+                text, output_path=str(root / 'speech.mp3'), speed=speed, provider=provider))
+            if not isinstance(result, dict) or result.get('success') is not True:
+                message = result.get('error') if isinstance(result, dict) else None
+                raise ValueError(str(message or 'Agent speech generation failed'))
+            paths = result.get('file_paths')
+            if not isinstance(paths, list) or not paths:
+                raise ValueError('Agent returned no audio files')
+            audio = bytearray()
+            audio_format = ''
+            for raw_path in paths:
+                path = Path(raw_path).resolve()
+                if not path.is_relative_to(root):
+                    raise ValueError('Agent audio escaped the temporary directory')
+                suffix = path.suffix.lower().lstrip('.')
+                if suffix not in ('mp3', 'wav', 'flac') or (len(paths) > 1 and suffix != 'mp3'):
+                    raise ValueError('Agent returned unsupported audio parts')
+                audio_format = suffix
+                with path.open('rb') as source:
+                    part = source.read(MAX_AUDIO_BYTES - len(audio) + 1)
+                if not part or len(audio) + len(part) > MAX_AUDIO_BYTES:
+                    raise ValueError('Agent audio is empty or exceeds 8 MiB')
+                audio.extend(part)
+            return {'provider': str(result.get('provider') or provider), 'format': audio_format,
+                    'audio_b64': base64.b64encode(audio).decode('ascii')}
+    except Exception as error:
+        raise RpcError(str(error), condition='tts_failed') from error
+
+
+def register(registry) -> None:
+    @registry.method('tts.synthesize')
+    def synthesize_(ctx: CallContext, params: dict) -> dict:
+        text, provider, speed = params.get('text'), params.get('provider'), params.get('speed')
+        if not isinstance(text, str) or not text.strip() or len(text) > 5000:
+            raise InvalidParams('text must contain 1 to 5000 characters')
+        if not isinstance(provider, str) or not provider.strip():
+            raise InvalidParams('provider is required')
+        if speed is not None and (isinstance(speed, bool) or not isinstance(speed, (int, float))
+                                  or not math.isfinite(speed) or not 0.5 <= speed <= 2):
+            raise InvalidParams('speed must be a number from 0.5 to 2')
+        with scoped_home(profile_home_param(params)):
+            return synthesize(text, provider, speed)

package/sidecar/talaria_sidecar/rpc.py

@@ -74,7 +74,10 @@ class CallContext:
 class RpcServer:
     def __init__(self, methods: dict[str, Handler], *, stdin=None, stdout=None, max_calls: int = DEFAULT_MAX_CALLS):
         self.methods = dict(methods)
-        self._slots = threading.BoundedSemaphore(max(1, int(max_calls)))
+        call_limit = max(1, int(max_calls))
+        self._slots = threading.BoundedSemaphore(call_limit)
+        # A parked command must leave room for its answer and unrelated Agent work.
+        self._command_slots = threading.BoundedSemaphore(min(8, call_limit - 1))
         self.methods.setdefault("rpc.cancel", self._cancel)
         self.methods.setdefault("rpc.methods", lambda ctx, params: {"methods": sorted(self.methods)})
         self._in = stdin or sys.stdin.buffer
@@ -256,7 +259,11 @@ class RpcServer:
                 # Cancellation must not queue behind the call it targets.
                 self._dispatch(request)
                 continue
-            if not self._slots.acquire(blocking=False):
+            command = request.get("method") == "commands.exec"
+            command_admitted = not command or self._command_slots.acquire(blocking=False)
+            if not command_admitted or not self._slots.acquire(blocking=False):
+                if command and command_admitted:
+                    self._command_slots.release()
                 if request.get("method") == "chat.start":
                     StartupTiming(request).finish("refused")
                 self._error(request.get("id"), APPLICATION_ERROR, "sidecar is at its concurrent call limit", {"condition": "sidecar_busy"})
@@ -279,3 +286,5 @@ class RpcServer:
             self._dispatch(request, ctx)
         finally:
             self._slots.release()
+            if request.get("method") == "commands.exec":
+                self._command_slots.release()