@maudecode/talaria-web 0.0.0 → 1.12.1

package/sidecar/talaria_sidecar/methods/chat.py

@@ -45,6 +45,8 @@ class _Run:
         self.finished = threading.Event()
         self.clarify_entries: dict[str, "_ClarifyEntry"] = {}
         self.lock = threading.Lock()
+        # The Agent's transcript list from before this turn: a Stop while the Agent still holds it has no checkpoint.
+        self.prior_messages = None
 
 
 class _ClarifyEntry:
@@ -81,6 +83,34 @@ def _snippet(raw: Any, limit: int = _TOOL_RESULT_SNIPPET_MAX) -> str:
     return text[:limit]
 
 
+_RAW_RESULT_MAX_KEYS = 64
+_RAW_RESULT_OUTCOME_KEYS = ("error", "exit_code", "exitCode", "success")
+
+
+def _raw_result(raw: Any, limit: int = _TOOL_RESULT_SNIPPET_MAX) -> Any:
+    """The tool result as the server's outcome rule reads it, bounded: a dict (or JSON-object text) keeps its first
+    ``_RAW_RESULT_MAX_KEYS`` top-level fields plus its outcome fields, scalars as they are, text and non-empty nested
+    values as capped (JSON) text; anything else is the capped text. The sidecar decides nothing; the server does."""
+    try:
+        data = raw if isinstance(raw, dict) else json.loads(str(raw or ""))
+    except Exception:  # noqa: BLE001
+        data = None
+    if not isinstance(data, dict):
+        return str(raw if raw is not None else "")[:limit]
+    out: dict = {}
+    # The server's outcome rule reads these, wherever they sit in the result.
+    kept = list(data.items())[:_RAW_RESULT_MAX_KEYS] + [(k, data[k]) for k in _RAW_RESULT_OUTCOME_KEYS if k in data]
+    for key, value in kept:
+        if value is None or isinstance(value, (bool, int)) or (isinstance(value, float) and value == value and abs(value) != float("inf")):
+            out[str(key)] = value
+        elif isinstance(value, (dict, list)) and not value:
+            out[str(key)] = {} if isinstance(value, dict) else []
+        else:
+            text = value if isinstance(value, str) else json.dumps(value, default=str)
+            out[str(key)] = text[:limit]
+    return out
+
+
 def _delegation_cost_usd(name: Any, raw: Any):
     """Predecessor ``_delegation_cost_usd``: total spend a ``delegate_task`` result reports, or None."""
     if str(name or "") != "delegate_task":
@@ -109,11 +139,66 @@ def _delegation_cost_usd(name: Any, raw: Any):
     return round(total, 6) if total > 0 else None
 
 
+def _js_number(value: int | float) -> str:
+    """A number as JavaScript's `String()` shows it once the persisted JSON is parsed (`1.0` -> `1`, `1e21` -> `1e+21`)."""
+    try:
+        number = float(value)
+    except OverflowError:
+        return "Infinity" if value > 0 else "-Infinity"
+    if number != number:
+        return "NaN"
+    if number in (float("inf"), float("-inf")):
+        return "Infinity" if number > 0 else "-Infinity"
+    if number == 0:
+        return "0"
+    sign = "-" if number < 0 else ""
+    # repr() gives the shortest round-trip digits, as JavaScript does; only the notation differs.
+    mantissa, _, exp = repr(abs(number)).partition("e")
+    whole, _, frac = mantissa.partition(".")
+    digits = (whole + frac).lstrip("0")
+    point = len(whole) + int(exp or 0) - (len(whole + frac) - len((whole + frac).lstrip("0")))
+    digits = digits.rstrip("0") or "0"
+    k, n = len(digits), point
+    if k <= n <= 21:
+        return sign + digits + "0" * (n - k)
+    if 0 < n <= 21:
+        return sign + digits[:n] + "." + digits[n:]
+    if -6 < n <= 0:
+        return sign + "0." + "0" * -n + digits
+    e = n - 1
+    return sign + digits[0] + ("." + digits[1:] if k > 1 else "") + "e" + ("+" if e >= 0 else "-") + str(abs(e))
+
+
+def _display_repr(text: str) -> str:
+    quote = '"' if "'" in text and '"' not in text else "'"
+    escaped = text.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+    return quote + escaped.replace(quote, "\\" + quote) + quote
+
+
+def _display_str(value: Any, nested: bool = False) -> str:
+    """A non-string argument as the server renders the parsed JSON of a persisted call (`pythonStr` in
+    `sessions/tool-display.ts`): Python `str()` shapes with JavaScript number text, so a live and a persisted call
+    show one target."""
+    if isinstance(value, str):
+        return _display_repr(value) if nested else value
+    if value is None:
+        return "None"
+    if isinstance(value, bool):
+        return "True" if value else "False"
+    if isinstance(value, (int, float)):
+        return _js_number(value)
+    if isinstance(value, (list, tuple)):
+        return "[" + ", ".join(_display_str(item, True) for item in value) + "]"
+    if isinstance(value, dict):
+        return "{" + ", ".join(f"{_display_repr(str(k))}: {_display_str(item, True)}" for k, item in value.items()) + "}"
+    return str(value)
+
+
 def _args_snapshot(args: Any) -> dict:
     snap: dict = {}
     if isinstance(args, dict):
         for k, v in list(args.items())[:4]:
-            s2 = str(v)
+            s2 = _display_str(v)
             cap = _TOOL_RESULT_SNIPPET_MAX if str(k).lower() in _TOOL_ARG_CONTENT_KEYS else 120
             snap[k] = s2[:cap] + ("..." if len(s2) > cap else "")
     return snap
@@ -181,6 +266,21 @@ def _agent_pending_steer_text(agent) -> str:
         return str(agent.__dict__.get("_pending_steer") or "")
 
 
+def _cancel_checkpoint(run: _Run) -> list | None:
+    """The Agent's canonical transcript at the stop boundary (the turn's prompt, completed tool calls and results),
+    which the live frames only project. The Agent republishes ``_session_messages`` after every tool round; until it
+    does, it still holds the previous turn's list and there is no checkpoint."""
+    agent = run.agent
+    messages = getattr(agent, "_session_messages", None) if agent is not None else None
+    if not isinstance(messages, list) or messages is run.prior_messages:
+        return None
+    try:
+        return json.loads(json.dumps([m for m in list(messages) if isinstance(m, dict)], default=str))
+    except Exception:  # noqa: BLE001 - a row the Agent is still mutating; Stop must not fail on it
+        log.debug("cancel checkpoint snapshot failed", exc_info=True)
+        return None
+
+
 def _resolve_runtime(provider: str | None, model: str) -> dict:
     try:
         from hermes_cli.runtime_provider import resolve_runtime_provider
@@ -386,7 +486,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
                     call["done"] = True
                     call["snippet"] = snippet
                     break
-            payload = {"event_type": "tool.completed", "name": name, "preview": snippet, "args": _args_snapshot(args), "tid": tid, "is_error": False}
+            payload = {"event_type": "tool.completed", "name": name, "preview": snippet, "args": _args_snapshot(args), "tid": tid, "raw_result": _raw_result(function_result)}
             cost = _delegation_cost_usd(name, function_result)
             if cost is not None:
                 payload["cost_usd"] = cost
@@ -415,13 +515,16 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             elif "non-retryable error" in lower:
                 emit("status", {"kind": "terminal_error", "message": text})
 
-        def clarify_callback(question, choices, questions=None):
+        def clarify_callback(question, choices, multi_select=False, questions=None):
             choices_list = [str(c) for c in (choices or [])]
             # Predecessor `_clarify_timeout_seconds`: the Agent's own resolver over this profile's config
             # (``clarify.timeout`` else ``agent.clarify_timeout`` else 3600); ``<= 0`` waits until answered or cancelled.
             # The advertised ``timeout_seconds`` is what the clients count down, so it is the same number.
             timeout = _clarify_timeout(params)
             data = {"question": str(question or ""), "choices_offered": choices_list, "session_id": session_id, "kind": "clarify", "requested_at": time.time(), "timeout_seconds": timeout}
+            if multi_select:
+                data["multi_select"] = True
+            # Batch prompts (the Agent's ``_run_batch``) carry no top-level question and expect the ``{"answers": {...}}`` reply.
             if isinstance(questions, list) and questions:
                 data["questions"] = questions
             entry = _ClarifyEntry(data)
@@ -525,6 +628,7 @@ def start(ctx: CallContext, params: dict) -> dict:  # noqa: PLR0915 - one turn,
             with _APPROVAL_CB_LOCK:
                 register_gateway_notify(session_id, approval_cb)
                 _APPROVAL_CB_OWNER[session_id] = stream_id
+        run.prior_messages = getattr(agent, "_session_messages", None)
         run.agent = agent
         compressions_before = int(getattr(getattr(agent, "context_compressor", None), "compression_count", 0) or 0)
 
@@ -649,6 +753,8 @@ def register(registry) -> None:
         run = _run_for(params)
         if run is None:
             return {"ok": False, "reason": "not_running"}
+        # Before the interrupt, so the unwinding Agent cannot reshape the transcript first.
+        checkpoint = _cancel_checkpoint(run)
         run.cancel.set()
         # Predecessor ``_finalize_webui_steers``: drain the Agent's not-yet-applied steer text so the server can
         # settle queued steers (consumed vs leftover) before it writes the terminal cancel row.
@@ -660,7 +766,10 @@ def register(registry) -> None:
                 pending = str(drain() or "") if callable(drain) else _agent_pending_steer_text(agent)
             except Exception:  # noqa: BLE001
                 pending = _agent_pending_steer_text(agent)
-        return {"ok": True, "pending_steer": pending}
+        result = {"ok": True, "pending_steer": pending}
+        if checkpoint is not None:
+            result["checkpoint"] = checkpoint
+        return result
 
     @registry.method("chat.steer", requires_agent=False)
     def steer_(ctx: CallContext, params: dict) -> dict:

package/sidecar/talaria_sidecar/methods/config.py

@@ -50,7 +50,9 @@ def read_config(path: Path) -> dict:
         raise
     except Exception as exc:  # noqa: BLE001
         raise RpcError(f"config.yaml is not valid YAML: {exc}", condition="config_invalid") from exc
-    return {"path": str(path), "exists": True, "config": data if isinstance(data, dict) else {}}
+    if data is not None and not isinstance(data, dict):
+        raise RpcError("config.yaml must contain a mapping", condition="config_invalid")
+    return {"path": str(path), "exists": True, "config": data if data is not None else {}}
 
 
 def _write_target(path: Path) -> Path:
@@ -117,11 +119,11 @@ def reasoning_efforts(model: str, provider: str) -> dict:
 
 
 def register(registry) -> None:
-    @registry.method("config.get", requires_agent=True)
+    @registry.method("config.get", requires_agent=False)
     def get(ctx: CallContext, params: dict) -> dict:
         return read_config(config_path_param(params))
 
-    @registry.method("config.set", requires_agent=True)
+    @registry.method("config.set", requires_agent=False)
     def set_(ctx: CallContext, params: dict) -> dict:
         return write_config(config_path_param(params), params.get("config"))
 

package/sidecar/talaria_sidecar/runtime.py

@@ -305,14 +305,8 @@ class AgentRuntime:
 
     # ── handshake ─────────────────────────────────────────────────────────
     def describe(self) -> dict:
-        # A checkout answers by revision; an untracked install (pip, image, no .git) must match the pinned version
-        # instead of passing unchecked, and an unknown version fails closed.
-        if not self.loaded:
-            compatible = False
-        elif self.revision is not None:
-            compatible = self.revision == self.pin["source_revision"]
-        else:
-            compatible = self.agent_version is not None and self.agent_version == self.pin["version"]
+        # The pin records official test coverage, not runtime capability. Each operation still checks its imports,
+        # profile isolation and loaded-revision guard at the point of use.
         return {
             "rpc_version": SIDECAR_RPC_VERSION,
             "python": sys.executable,
@@ -323,7 +317,7 @@ class AgentRuntime:
             "pinned_revision": self.pin["source_revision"],
             "pinned_version": self.pin["version"],
             "pinned_image": self.pin["image"],
-            "compatible": compatible,
+            "compatible": self.loaded,
             "stale": self.is_stale(),
             "update_state": self.update_transaction_state(),
             "import_error": self.import_error,