clay-server 4.0.0-beta.2 → 4.0.0-beta.21

package/lib/public/modules/tool-palette-order.js

@@ -0,0 +1,143 @@
+// tool-palette-order.js — the tool registry and the pure ordering rules.
+//
+// Extracted from tool-palette.js, which owns the DOM. Everything here is
+// pure data and pure functions over id lists: what tools exist, and what a
+// stored preference means today. Keeping it separate keeps the palette module
+// under the size limit and makes the ordering rules directly testable without
+// a browser.
+//
+// Two kinds of rule act on a stored preference, in this order:
+//   - legacy remap:  an id that was replaced by another tool
+//   - retirement:    an id whose tool was withdrawn with no replacement
+//
+// Neither rule ever overrides a live choice. A preference naming a tool that
+// still exists is honored exactly as saved; registry order is only the default
+// for a fresh palette and the append order for tools a saved list predates.
+
+// Registry order = default order for users who haven't customized. Users
+// with saved preferences keep their own order (applyPreferences uses
+// saved order first, then appends any registry entries the user's saved
+// list doesn't mention). So changes here only affect fresh palettes.
+var SESSION_TOOLS = [
+  { id: "file-browser-btn",        icon: "folder-tree",    label: "File browser" },
+  { id: "terminal-sidebar-btn",    icon: "square-terminal", label: "Terminal",        countId: "terminal-sidebar-count" },
+  { id: "sticky-notes-sidebar-btn", icon: "sticky-note",   label: "Sticky Notes",    countId: "sticky-notes-sidebar-count" },
+  { id: "project-logs-btn",        icon: "notebook-tabs",  label: "Logs",            countId: "project-logs-count" },
+  { id: "loop-tool-btn",           icon: "repeat",         label: "Loop" },
+  { id: "mcp-btn",                 icon: "cable",          label: "MCP Servers",     countId: "mcp-sidebar-count" },
+  { id: "skills-btn",              icon: "puzzle",         label: "Skills" },
+  { id: "scheduler-btn",           icon: "calendar-clock", label: "Scheduled Tasks" },
+];
+
+var MATE_TOOLS = [
+  { id: "mate-memory-btn",       icon: "brain",          label: "Memory",          countId: "mate-memory-count" },
+  { id: "mate-knowledge-btn",    icon: "book-open",      label: "Knowledge",       countId: "mate-knowledge-count" },
+  { id: "mate-sticky-notes-btn", icon: "sticky-note",    label: "Sticky Notes" },
+  { id: "mate-debate-btn",       icon: "mic",            label: "Debate" },
+  { id: "mate-mcp-btn",          icon: "cable",          label: "MCP Servers",     countId: "mate-mcp-sidebar-count" },
+  { id: "mate-skills-btn",       icon: "puzzle",         label: "Skills" },
+];
+
+export var PALETTES = {
+  session: {
+    tools: SESSION_TOOLS,
+    activeContainerId: "session-actions",
+    hiddenSectionId: "session-actions-hidden",
+  },
+  mate: {
+    tools: MATE_TOOLS,
+    activeContainerId: "mate-sidebar-tools",
+    hiddenSectionId: "mate-sidebar-tools-hidden",
+  },
+};
+
+// Tools that were replaced in the session palette. A saved preference naming
+// the old id would otherwise silently drop out (its element no longer exists)
+// and the replacement would append to the end of the palette instead of
+// inheriting the slot the user had chosen.
+//
+// There is no active remap. "scheduler-btn" used to map to "project-logs-btn"
+// from when Logs took the Scheduled Tasks slot; that remap is retired because
+// Scheduled Tasks is a live tool again, so a stored "scheduler-btn" once more
+// means exactly what it says and rewriting it would destroy the user's own
+// choice. The mechanism stays as the seam for the next replacement.
+var LEGACY_SESSION_TOOL_IDS = {};
+
+// Tools withdrawn from the session palette with no replacement. Git moved to
+// the always-visible repository placard below the tool strip, so it no longer
+// consumes an icon slot. A saved preference naming it is dropped rather than
+// left to linger in stored order forever.
+var RETIRED_SESSION_TOOL_IDS = ["git-sidebar-btn"];
+
+function indexOfId(list, id) {
+  for (var i = 0; i < list.length; i++) {
+    if (list[i] === id) return i;
+  }
+  return -1;
+}
+
+// Rewrite a saved preference so a replaced tool keeps its slot.
+//
+// If the user already has an explicit preference for the replacement, that
+// choice wins and the legacy id is simply dropped: their position, and whether
+// they hid it, are never overridden. Otherwise the legacy id is replaced in
+// place, at the exact index it occupied, in whichever list it appeared in.
+//
+// Exported for tests; returns new arrays and never mutates the input.
+export function normalizeToolPreferences(name, prefs) {
+  var order = (prefs && prefs.order) || [];
+  var hidden = (prefs && prefs.hidden) || [];
+  var result = { order: order.slice(), hidden: hidden.slice(), migrated: false };
+  if (name !== "session") return result;
+
+  var legacyIds = Object.keys(LEGACY_SESSION_TOOL_IDS);
+  for (var i = 0; i < legacyIds.length; i++) {
+    var legacyId = legacyIds[i];
+    var replacementId = LEGACY_SESSION_TOOL_IDS[legacyId];
+    var inOrder = indexOfId(result.order, legacyId) !== -1;
+    var inHidden = indexOfId(result.hidden, legacyId) !== -1;
+    if (!inOrder && !inHidden) continue;
+
+    var explicit = indexOfId(result.order, replacementId) !== -1
+      || indexOfId(result.hidden, replacementId) !== -1;
+    result.order = rewriteList(result.order, legacyId, replacementId, explicit);
+    result.hidden = rewriteList(result.hidden, legacyId, replacementId, explicit);
+    result.migrated = true;
+  }
+
+  for (var r = 0; r < RETIRED_SESSION_TOOL_IDS.length; r++) {
+    var retiredId = RETIRED_SESSION_TOOL_IDS[r];
+    if (indexOfId(result.order, retiredId) === -1 && indexOfId(result.hidden, retiredId) === -1) continue;
+    result.order = dropId(result.order, retiredId);
+    result.hidden = dropId(result.hidden, retiredId);
+    result.migrated = true;
+  }
+  return result;
+}
+
+function dropId(list, id) {
+  var out = [];
+  for (var i = 0; i < list.length; i++) {
+    if (list[i] !== id) out.push(list[i]);
+  }
+  return out;
+}
+
+// Drop the legacy id when the replacement is already chosen explicitly;
+// otherwise swap it in place. Any duplicate of the replacement introduced by
+// the swap is removed, keeping the first occurrence.
+function rewriteList(list, legacyId, replacementId, dropLegacy) {
+  var out = [];
+  var seen = {};
+  for (var i = 0; i < list.length; i++) {
+    var id = list[i];
+    if (id === legacyId) {
+      if (dropLegacy) continue;
+      id = replacementId;
+    }
+    if (seen[id]) continue;
+    seen[id] = true;
+    out.push(id);
+  }
+  return out;
+}

package/lib/public/modules/tool-palette-overlays.js

@@ -0,0 +1,159 @@
+// tool-palette-overlays.js — transient overlays that sit on top of the palette.
+//
+// Two independent, self-contained pieces extracted from tool-palette.js so
+// that module stays under the size limit: the right-click context menu, and
+// the Cmd/Ctrl+O hotkey pick mode. Neither owns palette state; the menu takes
+// its items (and their actions) from the caller, and pick mode works purely
+// off the rendered tiles. Behavior is unchanged by the move.
+
+import { PALETTES } from './tool-palette-order.js';
+
+// --- Right-click context menu ---
+
+var _openMenu = null;
+
+export function openPaletteContextMenu(x, y, items) {
+  closePaletteContextMenu();
+  var menu = document.createElement('div');
+  menu.className = 'tool-palette-ctx-menu';
+  for (var i = 0; i < items.length; i++) {
+    (function (item) {
+      var btn = document.createElement('button');
+      btn.type = 'button';
+      btn.className = 'tool-palette-ctx-item';
+      btn.textContent = item.label;
+      btn.addEventListener('click', function (e) {
+        e.stopPropagation();
+        closePaletteContextMenu();
+        item.action();
+      });
+      menu.appendChild(btn);
+    })(items[i]);
+  }
+  document.body.appendChild(menu);
+  // Clamp to viewport.
+  var rect = menu.getBoundingClientRect();
+  var px = x, py = y;
+  if (px + rect.width > window.innerWidth - 4) px = window.innerWidth - rect.width - 4;
+  if (py + rect.height > window.innerHeight - 4) py = window.innerHeight - rect.height - 4;
+  menu.style.left = px + 'px';
+  menu.style.top = py + 'px';
+  _openMenu = menu;
+}
+
+export function closePaletteContextMenu() {
+  if (_openMenu && _openMenu.parentNode) _openMenu.parentNode.removeChild(_openMenu);
+  _openMenu = null;
+}
+
+document.addEventListener('click', function () { closePaletteContextMenu(); });
+document.addEventListener('keydown', function (e) {
+  if (e.key === 'Escape') closePaletteContextMenu();
+});
+window.addEventListener('blur', function () { closePaletteContextMenu(); });
+window.addEventListener('resize', function () { closePaletteContextMenu(); });
+
+// --- Hotkey overlay (Cmd/Ctrl + O) ---
+//
+// Press Cmd/Ctrl + O to reveal a hotkey badge on each visible palette
+// tile. Then press the shown digit (1..9, 0) or letter (a..z) to
+// activate that tool. Escape or clicking away dismisses. Inspired by
+// Vimium / Superhuman-style "pick a tile with one keystroke" flows.
+
+var _pickActive = false;
+var HOTKEYS = (function () {
+  var k = [];
+  for (var i = 1; i <= 9; i++) k.push(String(i));
+  k.push('0');
+  for (var c = 97; c <= 122; c++) k.push(String.fromCharCode(c));
+  return k;
+})();
+
+function getVisiblePaletteName() {
+  // offsetParent is null when the element (or an ancestor) is hidden.
+  var mateActive = document.getElementById('mate-sidebar-tools');
+  if (mateActive && mateActive.offsetParent !== null) return 'mate';
+  var sessionActive = document.getElementById('session-actions');
+  if (sessionActive && sessionActive.offsetParent !== null) return 'session';
+  return null;
+}
+
+export function enterToolPickMode() {
+  if (_pickActive) return;
+  var name = getVisiblePaletteName();
+  if (!name) return;
+  var active = document.getElementById(PALETTES[name].activeContainerId);
+  if (!active) return;
+  var tiles = active.querySelectorAll('[data-tool-id]');
+  if (tiles.length === 0) return;
+  for (var i = 0; i < tiles.length && i < HOTKEYS.length; i++) {
+    var key = HOTKEYS[i];
+    tiles[i].dataset.hotkey = key;
+    var badge = document.createElement('span');
+    badge.className = 'tool-palette-hotkey-badge';
+    badge.textContent = key.toUpperCase();
+    tiles[i].appendChild(badge);
+  }
+  _pickActive = true;
+}
+
+export function exitToolPickMode() {
+  if (!_pickActive) return;
+  _pickActive = false;
+  var badges = document.querySelectorAll('.tool-palette-hotkey-badge');
+  for (var i = 0; i < badges.length; i++) {
+    if (badges[i].parentNode) badges[i].parentNode.removeChild(badges[i]);
+  }
+  var marked = document.querySelectorAll('[data-hotkey]');
+  for (var j = 0; j < marked.length; j++) {
+    delete marked[j].dataset.hotkey;
+  }
+}
+
+// Capture phase so we reliably preempt typing and browser shortcuts
+// when focus is in an input.
+document.addEventListener('keydown', function (e) {
+  // Pick mode: consume the next printable key.
+  if (_pickActive) {
+    if (e.key === 'Escape') {
+      e.preventDefault();
+      exitToolPickMode();
+      return;
+    }
+    // Ignore modifier-only keys; react to single-character keys.
+    if (e.key.length !== 1) return;
+    if (e.ctrlKey || e.metaKey || e.altKey) return;
+    var key = e.key.toLowerCase();
+    var tile = document.querySelector('[data-hotkey="' + key + '"]');
+    if (tile) {
+      e.preventDefault();
+      exitToolPickMode();
+      tile.click();
+    } else {
+      // Unknown key exits pick mode without triggering a tile.
+      exitToolPickMode();
+    }
+    return;
+  }
+
+  // Enter pick mode on Cmd/Ctrl + O (letter O). Intercepted globally
+  // including inside text inputs — the browser's native Cmd+O is a
+  // file-picker dialog Clay never wants, so taking it over costs the
+  // user nothing and is especially useful when jumping to a tool from
+  // the session search box.
+  if ((e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey && e.key && e.key.toLowerCase() === 'o') {
+    if (!getVisiblePaletteName()) return;
+    e.preventDefault();
+    enterToolPickMode();
+  }
+}, true);
+
+// Dismiss the overlay on click-away, blur, or viewport changes so it
+// never lingers invisibly.
+document.addEventListener('click', function () { if (_pickActive) exitToolPickMode(); });
+window.addEventListener('blur', function () { if (_pickActive) exitToolPickMode(); });
+window.addEventListener('resize', function () { if (_pickActive) exitToolPickMode(); });
+
+export function isToolPickActive() {
+  return _pickActive;
+}

package/lib/public/modules/tool-palette.js

@@ -14,44 +14,13 @@
 //   An in-flight save is debounced so rapid drag reorders don't spam.
 
 import { refreshIcons } from './icons.js';
-
-// Registry order = default order for users who haven't customized. Users
-// with saved preferences keep their own order (applyPreferences uses
-// saved order first, then appends any registry entries the user's saved
-// list doesn't mention). So changes here only affect fresh palettes.
-var SESSION_TOOLS = [
-  { id: "file-browser-btn",        icon: "folder-tree",    label: "File browser" },
-  { id: "terminal-sidebar-btn",    icon: "square-terminal", label: "Terminal",        countId: "terminal-sidebar-count" },
-  { id: "sticky-notes-sidebar-btn", icon: "sticky-note",   label: "Sticky Notes",    countId: "sticky-notes-sidebar-count" },
-  { id: "scheduler-btn",           icon: "calendar-clock", label: "Scheduled Tasks" },
-  { id: "loop-tool-btn",           icon: "repeat",         label: "Loop" },
-  { id: "git-sidebar-btn",         icon: "git-branch",     label: "Git",             countId: "git-sidebar-count" },
-  { id: "mcp-btn",                 icon: "cable",          label: "MCP Servers",     countId: "mcp-sidebar-count" },
-  { id: "skills-btn",              icon: "puzzle",         label: "Skills" },
-];
-
-var MATE_TOOLS = [
-  { id: "mate-memory-btn",       icon: "brain",          label: "Memory",          countId: "mate-memory-count" },
-  { id: "mate-knowledge-btn",    icon: "book-open",      label: "Knowledge",       countId: "mate-knowledge-count" },
-  { id: "mate-sticky-notes-btn", icon: "sticky-note",    label: "Sticky Notes" },
-  { id: "mate-scheduler-btn",    icon: "calendar-clock", label: "Scheduled Tasks" },
-  { id: "mate-debate-btn",       icon: "mic",            label: "Debate" },
-  { id: "mate-mcp-btn",          icon: "cable",          label: "MCP Servers",     countId: "mate-mcp-sidebar-count" },
-  { id: "mate-skills-btn",       icon: "puzzle",         label: "Skills" },
-];
-
-var PALETTES = {
-  session: {
-    tools: SESSION_TOOLS,
-    activeContainerId: "session-actions",
-    hiddenSectionId: "session-actions-hidden",
-  },
-  mate: {
-    tools: MATE_TOOLS,
-    activeContainerId: "mate-sidebar-tools",
-    hiddenSectionId: "mate-sidebar-tools-hidden",
-  },
-};
+import { PALETTES, normalizeToolPreferences } from './tool-palette-order.js';
+import {
+  enterToolPickMode,
+  exitToolPickMode,
+  isToolPickActive,
+  openPaletteContextMenu
+} from './tool-palette-overlays.js';
 
 var _saveTimers = {};
 var _draggingEl = null;
@@ -86,7 +55,7 @@ export function initToolPalettes() {
       // handler below, which would immediately tear down the pick-mode
       // we just entered.
       e.stopPropagation();
-      if (_pickActive) exitToolPickMode();
+      if (isToolPickActive()) exitToolPickMode();
       else enterToolPickMode();
     });
   }
@@ -303,152 +272,6 @@ function moveToActive(name, toolId) {
 // attached in buildToolButton before any external module attaches
 // handlers by ID. See the stopImmediatePropagation logic there.)
 
-// --- Right-click context menu ---
-
-var _openMenu = null;
-
-function openPaletteContextMenu(x, y, items) {
-  closePaletteContextMenu();
-  var menu = document.createElement('div');
-  menu.className = 'tool-palette-ctx-menu';
-  for (var i = 0; i < items.length; i++) {
-    (function (item) {
-      var btn = document.createElement('button');
-      btn.type = 'button';
-      btn.className = 'tool-palette-ctx-item';
-      btn.textContent = item.label;
-      btn.addEventListener('click', function (e) {
-        e.stopPropagation();
-        closePaletteContextMenu();
-        item.action();
-      });
-      menu.appendChild(btn);
-    })(items[i]);
-  }
-  document.body.appendChild(menu);
-  // Clamp to viewport.
-  var rect = menu.getBoundingClientRect();
-  var px = x, py = y;
-  if (px + rect.width > window.innerWidth - 4) px = window.innerWidth - rect.width - 4;
-  if (py + rect.height > window.innerHeight - 4) py = window.innerHeight - rect.height - 4;
-  menu.style.left = px + 'px';
-  menu.style.top = py + 'px';
-  _openMenu = menu;
-}
-
-function closePaletteContextMenu() {
-  if (_openMenu && _openMenu.parentNode) _openMenu.parentNode.removeChild(_openMenu);
-  _openMenu = null;
-}
-
-document.addEventListener('click', function () { closePaletteContextMenu(); });
-document.addEventListener('keydown', function (e) {
-  if (e.key === 'Escape') closePaletteContextMenu();
-});
-window.addEventListener('blur', function () { closePaletteContextMenu(); });
-window.addEventListener('resize', function () { closePaletteContextMenu(); });
-
-// --- Hotkey overlay (Cmd/Ctrl + O) ---
-//
-// Press Cmd/Ctrl + O to reveal a hotkey badge on each visible palette
-// tile. Then press the shown digit (1..9, 0) or letter (a..z) to
-// activate that tool. Escape or clicking away dismisses. Inspired by
-// Vimium / Superhuman-style "pick a tile with one keystroke" flows.
-
-var _pickActive = false;
-var HOTKEYS = (function () {
-  var k = [];
-  for (var i = 1; i <= 9; i++) k.push(String(i));
-  k.push('0');
-  for (var c = 97; c <= 122; c++) k.push(String.fromCharCode(c));
-  return k;
-})();
-
-function getVisiblePaletteName() {
-  // offsetParent is null when the element (or an ancestor) is hidden.
-  var mateActive = document.getElementById('mate-sidebar-tools');
-  if (mateActive && mateActive.offsetParent !== null) return 'mate';
-  var sessionActive = document.getElementById('session-actions');
-  if (sessionActive && sessionActive.offsetParent !== null) return 'session';
-  return null;
-}
-
-function enterToolPickMode() {
-  if (_pickActive) return;
-  var name = getVisiblePaletteName();
-  if (!name) return;
-  var active = document.getElementById(PALETTES[name].activeContainerId);
-  if (!active) return;
-  var tiles = active.querySelectorAll('[data-tool-id]');
-  if (tiles.length === 0) return;
-  for (var i = 0; i < tiles.length && i < HOTKEYS.length; i++) {
-    var key = HOTKEYS[i];
-    tiles[i].dataset.hotkey = key;
-    var badge = document.createElement('span');
-    badge.className = 'tool-palette-hotkey-badge';
-    badge.textContent = key.toUpperCase();
-    tiles[i].appendChild(badge);
-  }
-  _pickActive = true;
-}
-
-function exitToolPickMode() {
-  if (!_pickActive) return;
-  _pickActive = false;
-  var badges = document.querySelectorAll('.tool-palette-hotkey-badge');
-  for (var i = 0; i < badges.length; i++) {
-    if (badges[i].parentNode) badges[i].parentNode.removeChild(badges[i]);
-  }
-  var marked = document.querySelectorAll('[data-hotkey]');
-  for (var j = 0; j < marked.length; j++) {
-    delete marked[j].dataset.hotkey;
-  }
-}
-
-// Capture phase so we reliably preempt typing and browser shortcuts
-// when focus is in an input.
-document.addEventListener('keydown', function (e) {
-  // Pick mode: consume the next printable key.
-  if (_pickActive) {
-    if (e.key === 'Escape') {
-      e.preventDefault();
-      exitToolPickMode();
-      return;
-    }
-    // Ignore modifier-only keys; react to single-character keys.
-    if (e.key.length !== 1) return;
-    if (e.ctrlKey || e.metaKey || e.altKey) return;
-    var key = e.key.toLowerCase();
-    var tile = document.querySelector('[data-hotkey="' + key + '"]');
-    if (tile) {
-      e.preventDefault();
-      exitToolPickMode();
-      tile.click();
-    } else {
-      // Unknown key exits pick mode without triggering a tile.
-      exitToolPickMode();
-    }
-    return;
-  }
-
-  // Enter pick mode on Cmd/Ctrl + O (letter O). Intercepted globally
-  // including inside text inputs — the browser's native Cmd+O is a
-  // file-picker dialog Clay never wants, so taking it over costs the
-  // user nothing and is especially useful when jumping to a tool from
-  // the session search box.
-  if ((e.metaKey || e.ctrlKey) && !e.altKey && !e.shiftKey && e.key && e.key.toLowerCase() === 'o') {
-    if (!getVisiblePaletteName()) return;
-    e.preventDefault();
-    enterToolPickMode();
-  }
-}, true);
-
-// Dismiss the overlay on click-away, blur, or viewport changes so it
-// never lingers invisibly.
-document.addEventListener('click', function () { if (_pickActive) exitToolPickMode(); });
-window.addEventListener('blur', function () { if (_pickActive) exitToolPickMode(); });
-window.addEventListener('resize', function () { if (_pickActive) exitToolPickMode(); });
-
 function getDragAfterElement(container, x, y) {
   var tiles = Array.prototype.slice.call(
     container.querySelectorAll('[data-tool-id]:not(.dragging)')
@@ -495,13 +318,17 @@ function applyPreferences(name, prefs) {
   var hiddenGrid = hiddenSection ? hiddenSection.querySelector('.tool-palette-hidden-grid') : null;
   if (!active || !hiddenGrid) return;
 
+  var normalized = normalizeToolPreferences(name, prefs);
+
   var hiddenSet = {};
-  var hiddenList = prefs.hidden || [];
+  var hiddenList = normalized.hidden;
   for (var i = 0; i < hiddenList.length; i++) hiddenSet[hiddenList[i]] = true;
 
-  var orderList = prefs.order || [];
+  var orderList = normalized.order;
   // Any tools not in the stored order are appended in registry order so
-  // newly-added tools surface automatically for existing users.
+  // newly-added tools surface automatically for existing users. This is how
+  // a restored tool reaches a saved palette that predates it: no rewrite, no
+  // server state, just the normal new-registry append.
   var placed = {};
   for (var j = 0; j < orderList.length; j++) {
     var id = orderList[j];
@@ -525,6 +352,12 @@ function applyPreferences(name, prefs) {
       hiddenGrid.appendChild(hbtn);
     }
   }
+
+  // Write the rewritten preference back once, through the normal save path, so
+  // the migration survives reloads and reaches the user's other devices. The
+  // save reads the DOM this function just arranged, so it records exactly what
+  // is on screen.
+  if (normalized.migrated) queueSave(name);
 }
 
 function queueSave(name) {

package/lib/public/modules/tools.js

@@ -203,6 +203,23 @@ export function toolActivityText(name, input) {
   return "Running " + name + "...";
 }
 
+// The sublabel for a call that has finished. `toolActivityText` is written in
+// the present progressive for a call in flight, so re-asserting it after a
+// result has arrived leaves a finished card claiming to still be running —
+// which is how a failed custom tool ended up reading "Running
+// send_to_partner..." beside its own error output.
+//
+// Only ever used where a result exists, so a genuinely in-flight call is never
+// relabelled. A failure states so plainly; a success keeps whatever specific
+// description the activity text produced ("Reading foo.js"), because that still
+// describes the call accurately, and only the generic present-progressive
+// fallback is replaced.
+export function toolTerminalText(name, input, isError) {
+  if (isError) return name + " failed";
+  var activity = toolActivityText(name, input);
+  return activity === "Running " + name + "..." ? name : activity;
+}
+
 function shortPath(p) {
   if (!p) return "";
   var parts = p.split("/");
@@ -2136,9 +2153,12 @@ export function updateToolResult(id, content, isError, images) {
   var tool = tools[id];
   if (!tool) return;
 
+  // Re-render the sublabel from the now-complete input (streaming can have
+  // built it from a partial one), but in its terminal form: a result has
+  // arrived, so this call is no longer running.
   var subtitleText = tool.el.querySelector(".tool-subtitle-text");
   if (subtitleText && tool.input) {
-    subtitleText.textContent = toolActivityText(tool.name, tool.input);
+    subtitleText.textContent = toolTerminalText(tool.name, tool.input, isError);
   }
 
   var resultBlock = document.createElement("div");