tools
@@ -497,6 +519,8 @@ body {
waiting for wire telemetry…
no chain-of-thought captured yet
persona state loads on session open
+
bifrost dispatch state loads on session open
+
admin lifecycle events stream on session open
@@ -542,7 +566,7 @@ body {
"use strict";
const $ = (id) => document.getElementById(id);
-const state = { sessionId: null, agentId: null, turnId: null, eventSource: null };
+const state = { sessionId: null, agentId: null, turnId: null, eventSource: null, lastAffectAt: null, adminES: null };
function esc(s) {
const d = document.createElement("div");
@@ -603,8 +627,46 @@ function markdownSafe(raw) {
// per-turn live buffers (reset at turn open)
const LIVE = { resp: "", think: "" };
+// ---- reasoning indicator (a UI affordance — NOT engine output) ----------
+// When the model streams reasoning/chain-of-thought, show an ephemeral
+// " is pondering…" line in the transcript so the user knows inference
+// is happening. Rotates phrasing for liveliness; removed the instant real text
+// begins or the turn ends. agentDisplayName is rendered via textContent (never
+// innerHTML) so an adversarial agent_id can't inject markup (INV-004).
+const THINK_PHRASES = ["is thinking", "is pondering", "appears thoughtful",
+ "is reasoning", "is turning it over"];
+let thinkRotator = null;
+function agentDisplayName() {
+ if (!state.agentId) return "the agent";
+ const tail = String(state.agentId).split(":").pop() || "the agent";
+ return tail.charAt(0).toUpperCase() + tail.slice(1);
+}
+function showThinkingNote() {
+ // reasoning tokens ARE the first tokens — supersede the awaiting-first heartbeat
+ const aw = document.querySelector("#transcript .awaiting.live");
+ if (aw) aw.remove();
+ let el = document.querySelector("#transcript .thinking-note");
+ if (!el) {
+ el = document.createElement("div");
+ el.className = "thinking-note";
+ el.appendChild(document.createTextNode(""));
+ $("transcript").appendChild(el);
+ let i = 0;
+ const paint = () => { el.firstChild.textContent =
+ `${agentDisplayName()} ${THINK_PHRASES[i % THINK_PHRASES.length]}`; i++; };
+ paint();
+ thinkRotator = setInterval(paint, 2600);
+ }
+ $("transcript").scrollTop = $("transcript").scrollHeight;
+}
+function hideThinkingNote() {
+ if (thinkRotator) { clearInterval(thinkRotator); thinkRotator = null; }
+ const el = document.querySelector("#transcript .thinking-note");
+ if (el) el.remove();
+}
+
// ---- pane helpers ----
-const PANE_BADGE = { tools: 0, debug: 0, thinking: 0 };
+const PANE_BADGE = { tools: 0, debug: 0, thinking: 0, admin: 0 };
function bumpBadge(pane) {
if (!(pane in PANE_BADGE)) return;
PANE_BADGE[pane] += 1;
@@ -773,6 +835,7 @@ async function loadAffect(agentId) {
const snap = await r.json();
renderAffectPane(snap);
setPersonaStrip(snap); // pad bars are the live signal
+ state.lastAffectAt = snap.emitted_at || state.lastAffectAt; // post-turn poll stop-signal
} else {
let code = "";
try { code = (await r.json()).error_code || ""; } catch (_) {}
@@ -794,6 +857,93 @@ async function loadAffect(agentId) {
}
}
+// ---- tools inventory (#183): what the LLM HAS at turn-fire (static), rendered
+// at the TOP of the tools pane; live tool_start/result events append below it. ---
+function renderToolsInventory(inv) {
+ const row = (k, v) => `${esc(k)} ${esc(v)}
`;
+ const head = (t) => `${esc(t)}
`;
+ const names = (arr) => (arr || []).map((t) => (typeof t === "string" ? t : (t && t.name) || "?"));
+ const builtin = inv.builtin_tools || [], bifrost = inv.bifrost_tools || [];
+ const html =
+ head("tool inventory · " + (inv.agent_id || "?")) +
+ row("builtin (" + builtin.length + ")", names(builtin).join(", ") || "none") +
+ row("bifrost (" + bifrost.length + ")", names(bifrost).join(", ") || "none") +
+ `— live tool events —
`;
+ const pane = $("pane-tools");
+ const empty = pane.querySelector(".empty");
+ if (empty) empty.remove();
+ let block = pane.querySelector(".tools-inventory");
+ if (!block) {
+ block = document.createElement("div");
+ block.className = "tools-inventory";
+ pane.insertBefore(block, pane.firstChild);
+ }
+ block.innerHTML = html;
+}
+async function loadSessionTools(sessionId) {
+ try {
+ const r = await fetch("/api/sessions/" + encodeURIComponent(sessionId) + "/tools");
+ if (r.status === 200) renderToolsInventory(await r.json());
+ // non-200 → best-effort hydrate; leave the live tool pane as-is (mirrors TUI)
+ } catch (_) {}
+}
+
+// ---- Bifrost dispatch state (#176): admin-scoped, server-proxied (admin key
+// stays server-side; the browser only receives the state). ----
+function renderBifrostState(b) {
+ const row = (k, v) => `${esc(k)} ${esc(v)}
`;
+ const head = (t) => `${esc(t)}
`;
+ const tools = b.tools || [];
+ $("pane-bifrost").innerHTML =
+ head("bifrost dispatch state") +
+ row("endpoint", b.endpoint_url || "?") +
+ row("consumer", b.consumer_id || "?") +
+ row("connected", JSON.stringify(b.connected)) +
+ row("caps", (b.capabilities_granted || []).join(", ") || "none") +
+ `
` + head("tools (" + tools.length + ")") +
+ (tools.map((t) => row("·", (t.name || "?") + (t.description ? " — " + t.description : ""))).join("")
+ || `none
`);
+}
+async function loadBifrostState(sessionId) {
+ try {
+ const r = await fetch("/api/sessions/" + encodeURIComponent(sessionId) + "/bifrost");
+ if (r.status === 200) { renderBifrostState(await r.json()); return; }
+ let code = ""; try { code = (await r.json()).error_code || ""; } catch (_) {}
+ let msg;
+ if (code === "admin_key_not_configured") msg = "bifrost state needs the readonly-admin key (RATATOSKR_ADMIN_API_KEY) server-side.";
+ else if (r.status === 404) msg = "session is not Bifrost-bound (no live dispatch client).";
+ else if (r.status === 403) msg = "admin key lacks the admin.sessions.read scope.";
+ else msg = `bifrost state unavailable (HTTP ${esc(r.status)}${code ? " · " + esc(code) : ""}).`;
+ $("pane-bifrost").innerHTML = `${msg}
`;
+ } catch (_) {
+ $("pane-bifrost").innerHTML = `bifrost state fetch failed
`;
+ }
+}
+
+// ---- Admin lifecycle events (#11): admin-scoped SSE, session-filtered SERVER-side.
+// One fixed "admin_event" listener renders every type; the dotted type is in data. ---
+function openAdminEvents(sessionId) {
+ if (state.adminES) { state.adminES.close(); state.adminES = null; }
+ const es = new EventSource("/api/admin/events?session_id=" + encodeURIComponent(sessionId));
+ state.adminES = es;
+ es.addEventListener("admin_event", (e) => {
+ let d; try { d = JSON.parse(e.data); } catch (_) { return; }
+ appendTo("pane-admin",
+ `[${ts()}] ${esc(d.type || "event")} `
+ + `${esc(JSON.stringify(d.data || {}))}
`);
+ });
+ es.addEventListener("stream_error", (e) => {
+ let d = {}; try { d = JSON.parse(e.data); } catch (_) {}
+ appendTo("pane-admin", `— admin stream ended: ${esc(d.exception || "error")} —
`);
+ });
+ es.onerror = () => {
+ const pane = $("pane-admin");
+ if (pane.querySelector(".empty")) {
+ pane.innerHTML = `admin stream unavailable — needs the readonly-admin key + admin.events.read scope.
`;
+ }
+ };
+}
+
// ---- session lifecycle ----
async function startSession() {
const agentId = $("agent-picker").value;
@@ -837,6 +987,11 @@ async function startSession() {
$("setup").style.display = "none";
$("workspace").classList.add("live");
await loadPersona(agentId);
+ // Admin/debug surfaces — best-effort hydrate + live stream (all self-render on
+ // failure; the admin key is server-held, never sent from here).
+ loadSessionTools(state.sessionId);
+ loadBifrostState(state.sessionId);
+ openAdminEvents(state.sessionId);
$("prompt-input").focus();
} catch (e) {
$("setup-err").textContent = "network error opening session";
@@ -943,11 +1098,13 @@ async function submitPrompt() {
es.addEventListener("thinking", (e) => {
const d = JSON.parse(e.data);
thinkingDeltas += 1;
+ showThinkingNote(); // ephemeral " is pondering…" in the transcript
appendThinking(d.content);
});
es.addEventListener("text", (e) => {
const d = JSON.parse(e.data);
textDeltas += 1;
+ hideThinkingNote(); // real text begins — reasoning display is done
appendResponse(d.content);
});
es.addEventListener("text_boundary", (e) => {
@@ -990,6 +1147,7 @@ async function submitPrompt() {
function terminal(label, cls, e) {
const aw = document.querySelector("#transcript .awaiting.live");
if (aw) aw.remove();
+ hideThinkingNote();
finalizeResponse();
document.querySelectorAll("#pane-thinking .think-live").forEach((b) => b.classList.remove("think-live"));
let meta = "";
@@ -1006,9 +1164,18 @@ async function submitPrompt() {
$("composer").classList.remove("streaming");
setConn(cls === "error" ? "error" : "idle", cls === "error" ? "error" : "connected");
if (cls === "done" && state.agentId) {
- // Tier-3 affect.emit is POST-TURN ASYNC — it lands in our store a couple seconds
- // after [done]. Refresh the pane on a short delay to catch the new PAD (issue #18).
- setTimeout(() => loadPersona(state.agentId), 2000);
+ // Tier-3 affect.emit is POST-TURN ASYNC and can land well after [done] — a single
+ // fixed refresh races it (issue #18 foot-gun). Poll a short window, stopping once
+ // the snapshot's emitted_at advances past the pre-turn value (or a new turn starts).
+ const beforeAt = state.lastAffectAt;
+ let settled = false;
+ for (const delay of [1500, 3500, 6500, 10500]) {
+ setTimeout(async () => {
+ if (settled || state.turnId) return;
+ await loadPersona(state.agentId);
+ if (state.lastAffectAt && state.lastAffectAt !== beforeAt) settled = true;
+ }, delay);
+ }
}
$("prompt-input").focus();
}
@@ -1053,7 +1220,7 @@ document.querySelectorAll(".tab").forEach((t) =>
// ---- keyboard ----
document.addEventListener("keydown", (e) => {
- if (e.ctrlKey && ["1", "2", "3", "4"].includes(e.key)) {
+ if (e.ctrlKey && ["1", "2", "3", "4", "5", "6"].includes(e.key)) {
const tabs = document.querySelectorAll(".tab");
const idx = parseInt(e.key, 10) - 1;
if (tabs[idx]) { activateTab(tabs[idx]); e.preventDefault(); }
diff --git a/tests/test_web_server.py b/tests/test_web_server.py
index 641065e..35cc8a1 100644
--- a/tests/test_web_server.py
+++ b/tests/test_web_server.py
@@ -1062,3 +1062,123 @@ class TestAffectStateEndpoint:
resp = TestClient(app).get("/api/affect/ratatoskr:sindra")
assert resp.status_code == 400
assert resp.json()["error_code"] == "missing_end_user_id"
+
+
+class TestSessionToolsEndpoint:
+ """session_tools_endpoint — proxy owner-scoped GET /sessions/{id}/tools (#183)."""
+
+ @respx.mock
+ def test_happy_returns_inventory(self) -> None:
+ """happy [tracer]: 200 inventory → 200 verbatim."""
+ respx.get("https://w.example/sessions/s-1/tools").mock(
+ return_value=httpx.Response(200, json={
+ "agent_id": "ratatoskr:sindra",
+ "builtin_tools": ["echo"],
+ "bifrost_tools": [{"name": "memory.search"}],
+ })
+ )
+ from ratatoskr.web.server import create_app
+ resp = TestClient(create_app(_mock_client_factory())).get("/api/sessions/s-1/tools")
+ assert resp.status_code == 200
+ assert resp.json()["agent_id"] == "ratatoskr:sindra"
+
+ @respx.mock
+ def test_upstream_404_status_preserving_envelope(self) -> None:
+ """error: upstream 404 → 404 session_tools_unavailable envelope."""
+ respx.get("https://w.example/sessions/s-1/tools").mock(
+ return_value=httpx.Response(404, content=b"nope")
+ )
+ from ratatoskr.web.server import create_app
+ resp = TestClient(create_app(_mock_client_factory())).get("/api/sessions/s-1/tools")
+ assert resp.status_code == 404
+ assert resp.json()["error_code"] == "session_tools_unavailable"
+
+
+class TestSessionBifrostEndpoint:
+ """session_bifrost_endpoint — proxy admin-scoped GET /admin/sessions/{id}/bifrost (#176)."""
+
+ @respx.mock
+ def test_happy_overrides_with_admin_bearer(self) -> None:
+ """happy [tracer]: 200 state → 200; request carries the ADMIN bearer, not consumer."""
+ route = respx.get("https://w.example/admin/sessions/s-1/bifrost").mock(
+ return_value=httpx.Response(200, json={
+ "endpoint_url": "http://x:8392", "connected": True,
+ "capabilities_granted": ["memory", "affect"], "tools": [],
+ })
+ )
+ from ratatoskr.web.server import create_app
+ app = create_app(_mock_client_factory(), admin_key="adm-key")
+ resp = TestClient(app).get("/api/sessions/s-1/bifrost")
+ assert resp.status_code == 200
+ assert resp.json()["connected"] is True
+ assert route.calls.last.request.headers["Authorization"] == "Bearer adm-key"
+
+ def test_no_admin_key_fails_visible_400(self) -> None:
+ """error: no admin key configured → 400 admin_key_not_configured, no upstream call."""
+ from ratatoskr.web.server import create_app
+ app = create_app(_mock_client_factory()) # no admin_key
+ resp = TestClient(app).get("/api/sessions/s-1/bifrost")
+ assert resp.status_code == 400
+ assert resp.json()["error_code"] == "admin_key_not_configured"
+
+ @respx.mock
+ def test_upstream_404_status_preserving_envelope(self) -> None:
+ """error: upstream 404 (not bound) → 404 bifrost_state_unavailable envelope."""
+ respx.get("https://w.example/admin/sessions/s-1/bifrost").mock(
+ return_value=httpx.Response(404, content=b"nope")
+ )
+ from ratatoskr.web.server import create_app
+ app = create_app(_mock_client_factory(), admin_key="adm-key")
+ resp = TestClient(app).get("/api/sessions/s-1/bifrost")
+ assert resp.status_code == 404
+ assert resp.json()["error_code"] == "bifrost_state_unavailable"
+
+
+class TestAdminEventsEndpoint:
+ """admin_events_endpoint — SSE proxy of GET /admin/events, session-filtered (#11)."""
+
+ def test_filter_semantics(self) -> None:
+ """unit: heartbeats drop, system.* pass, else match on session_id."""
+ from ratatoskr.sse_client import AdminEvent
+ from ratatoskr.web.server import _admin_event_matches_web
+
+ def mk(t: str, sid: "str | None" = None) -> AdminEvent:
+ return AdminEvent(id=1, type=t, timestamp=None,
+ data={"session_id": sid} if sid else {})
+
+ assert _admin_event_matches_web(mk("system.heartbeat"), "s-1") is False
+ assert _admin_event_matches_web(mk("system.degraded"), "s-1") is True
+ assert _admin_event_matches_web(mk("session.created", "s-1"), "s-1") is True
+ assert _admin_event_matches_web(mk("session.created", "other"), "s-1") is False
+ assert _admin_event_matches_web(mk("session.created", "s-1"), None) is False
+
+ def test_no_admin_key_fails_visible_400(self) -> None:
+ """error: no admin key → 400 admin_key_not_configured (no stream opened)."""
+ from ratatoskr.web.server import create_app
+ app = create_app(_mock_client_factory())
+ resp = TestClient(app).get("/api/admin/events?session_id=s-1")
+ assert resp.status_code == 400
+ assert resp.json()["error_code"] == "admin_key_not_configured"
+
+ @respx.mock
+ def test_streams_filtered_events_fixed_name(self) -> None:
+ """happy: SSE → only session-matching + system.* forwarded, as `admin_event`."""
+ stream = (
+ b'event: session.created\n'
+ b'data: {"type":"session.created","data":{"session_id":"s-1"}}\n\n'
+ b'event: system.heartbeat\n'
+ b'data: {"type":"system.heartbeat","data":{}}\n\n'
+ b'event: turn.started\n'
+ b'data: {"type":"turn.started","data":{"session_id":"other"}}\n\n'
+ b'event: system.degraded\n'
+ b'data: {"type":"system.degraded","data":{}}\n\n'
+ )
+ respx.get("https://w.example/admin/events").mock(return_value=_sse_resp(stream))
+ from ratatoskr.web.server import create_app
+ app = create_app(_mock_client_factory(), admin_key="adm-key")
+ body = TestClient(app).get("/api/admin/events?session_id=s-1").text
+ assert "event: admin_event" in body # fixed browser-facing name
+ assert '"type": "session.created"' in body # matches active session → forwarded
+ assert "system.degraded" in body # system.* → forwarded
+ assert "system.heartbeat" not in body # heartbeat → dropped
+ assert "turn.started" not in body # other session → dropped
diff --git a/uv.lock b/uv.lock
index 1f94ece..b1d7db6 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1052,7 +1052,7 @@ wheels = [
[[package]]
name = "ratatoskr"
-version = "0.19.1"
+version = "0.19.2"
source = { editable = "." }
dependencies = [
{ name = "httpx" },