clay-server 4.0.0-beta.9 → 4.0.0

package/lib/public/modules/thinking-lifecycle.js

@@ -0,0 +1,175 @@
+import { escapeHtml } from './utils.js';
+import { iconHtml, refreshIcons } from './icons.js';
+import { store } from './store.js';
+import { addToMessages, scrollToBottom } from './chat-render-runtime.js';
+import { prepareThinkingView, bindThinkingView, updateThinkingView, beginThinkingView, setThinkingViewLive, finishThinkingView } from './thinking-view.js';
+
+function getThinkingState() {
+  return store.get('thinkingState') || null;
+}
+
+function setThinkingState(state) {
+  store.set({ thinkingState: state });
+}
+
+function updateThinkingState(state, patch) {
+  var next = Object.assign({}, state, patch);
+  setThinkingState(next);
+  return next;
+}
+
+function isMateThinking() {
+  var target = store.get('dmTargetUser');
+  return !!(store.get('dmMode') && target && target.isMate);
+}
+
+function maybeScrollToBottom() {
+  if (!store.get('replayingHistory')) scrollToBottom();
+}
+
+function createThinkingElement() {
+  var el = document.createElement("div");
+  el.className = "thinking-item";
+  if (isMateThinking()) {
+    var target = store.get('dmTargetUser');
+    var mateName = (target && target.displayName) || "Mate";
+    var mateAvatar = document.body.dataset.mateAvatarUrl || "";
+    el.classList.add("mate-thinking");
+    el.innerHTML =
+      '<img class="dm-bubble-avatar dm-bubble-avatar-mate" src="' + escapeHtml(mateAvatar) + '" alt="">' +
+      '<div class="dm-bubble-content">' +
+      '<div class="dm-bubble-header"><span class="dm-bubble-name">' + escapeHtml(mateName) + '</span></div>' +
+      '<div class="mate-thinking-dots mate-thinking-activity"><span></span><span></span><span></span></div>' +
+      '<div class="thinking-header" style="display:none">' +
+      '<span class="thinking-chevron">' + iconHtml("chevron-right") + '</span>' +
+      '<span class="thinking-label">Thinking</span>' +
+      '<span class="thinking-duration"></span>' +
+      '<span class="thinking-spinner">' + iconHtml("loader", "icon-spin") + '</span>' +
+      '</div>' +
+      '<div class="thinking-content"></div>' +
+      '</div>';
+  } else {
+    el.innerHTML =
+      '<div class="thinking-header">' +
+      '<span class="thinking-chevron">' + iconHtml("chevron-right") + '</span>' +
+      '<span class="thinking-label">Thinking</span>' +
+      '<span class="thinking-duration"></span>' +
+      '<span class="thinking-spinner">' + iconHtml("loader", "icon-spin") + '</span>' +
+      '</div>' +
+      '<div class="thinking-content"></div>';
+  }
+  prepareThinkingView(el);
+  bindThinkingView(el);
+  addToMessages(el);
+  return el;
+}
+
+function showMateActivity(el, active, hasContent) {
+  if (!el.classList.contains("mate-thinking")) return;
+  var activity = el.querySelector(".mate-thinking-activity");
+  var header = el.querySelector(".thinking-header");
+  if (activity) activity.style.display = active ? "" : "none";
+  if (header) header.style.display = active || !hasContent ? "none" : "";
+}
+
+export function startThinkingSegment() {
+  var thinkingState = getThinkingState();
+  if (thinkingState && thinkingState.active) return thinkingState.el;
+  if (!thinkingState || thinkingState.ended) {
+    thinkingState = {
+      el: createThinkingElement(),
+      detailsText: "",
+      segmentText: "",
+      latestText: "",
+      active: false,
+      ended: false,
+      startTime: 0,
+      totalDuration: 0,
+    };
+  }
+  thinkingState = updateThinkingState(thinkingState, {
+    active: true,
+    segmentText: "",
+    startTime: Date.now(),
+  });
+  beginThinkingView(thinkingState.el, !store.get('replayingHistory') && !isMateThinking());
+  showMateActivity(thinkingState.el, true, !!thinkingState.detailsText.trim());
+  refreshIcons();
+  maybeScrollToBottom();
+  return thinkingState.el;
+}
+
+export function appendThinkingText(text) {
+  var thinkingState = getThinkingState();
+  if (!thinkingState || !thinkingState.active || typeof text !== "string" || !text) return;
+  var separator = !thinkingState.segmentText && thinkingState.detailsText ? "\n\n" : "";
+  var segmentText = thinkingState.segmentText + text;
+  thinkingState = updateThinkingState(thinkingState, {
+    segmentText: segmentText,
+    detailsText: thinkingState.detailsText + separator + text,
+    latestText: segmentText.trim() ? segmentText : thinkingState.latestText,
+  });
+  updateThinkingView(thinkingState.el, thinkingState.segmentText || thinkingState.latestText, thinkingState.detailsText);
+  maybeScrollToBottom();
+}
+
+export function stopThinkingSegment(duration) {
+  var thinkingState = getThinkingState();
+  if (!thinkingState || !thinkingState.active) return;
+  var seconds = typeof duration === "number" ? duration : (Date.now() - thinkingState.startTime) / 1000;
+  thinkingState = updateThinkingState(thinkingState, {
+    totalDuration: thinkingState.totalDuration + seconds,
+    active: false,
+  });
+  finishThinkingView(thinkingState.el, thinkingState.latestText, thinkingState.detailsText);
+  thinkingState.el.querySelector(".thinking-duration").textContent = " " + thinkingState.totalDuration.toFixed(1) + "s";
+  showMateActivity(thinkingState.el, false, !!thinkingState.detailsText.trim());
+}
+
+export function finishThinkingTurn() {
+  var thinkingState = getThinkingState();
+  if (!thinkingState) return;
+  stopThinkingSegment();
+  thinkingState = getThinkingState();
+  thinkingState = updateThinkingState(thinkingState, { ended: true });
+  finishThinkingView(thinkingState.el, thinkingState.latestText, thinkingState.detailsText);
+  showMateActivity(thinkingState.el, false, !!thinkingState.detailsText.trim());
+}
+
+export function resetThinkingTurn() {
+  finishThinkingTurn();
+  setThinkingState(null);
+}
+
+export function clearThinkingState() {
+  setThinkingState(null);
+}
+
+export function saveThinkingState() {
+  return getThinkingState();
+}
+
+export function restoreThinkingState(saved) {
+  setThinkingState(saved || null);
+}
+
+export function resumeThinkingAfterReplay(processing) {
+  var thinkingState = getThinkingState();
+  if (!thinkingState || !thinkingState.active || !processing) return;
+  setThinkingViewLive(thinkingState.el, !isMateThinking());
+  showMateActivity(thinkingState.el, true, !!thinkingState.detailsText.trim());
+}
+
+export function updateThinkingTokenEstimate(estimatedTokens) {
+  var thinkingState = getThinkingState();
+  if (!thinkingState || !thinkingState.active || !thinkingState.el) return;
+  var label = thinkingState.el.querySelector(".thinking-label");
+  if (!label) return;
+  var count = estimatedTokens || 0;
+  var display = count >= 1000 ? ("~" + (Math.round(count / 100) / 10) + "k") : ("~" + count);
+  if (thinkingState.latestText.trim()) {
+    label.title = label.textContent + " · " + display + " tokens";
+  } else {
+    label.textContent = "Thinking " + display + " tokens";
+  }
+}

package/lib/public/modules/thinking-summary.js

@@ -0,0 +1,28 @@
+// Summarize only supplied text; a heading is preferable to a prose excerpt.
+function plainText(text) {
+  return text.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1")
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+    .replace(/^\s*(?:#{1,6}\s+|>\s*)/gm, "")
+    .replace(/[*_`~]/g, "")
+    .replace(/\s+/g, " ").trim();
+}
+
+export function thinkingSummary(text) {
+  if (typeof text !== "string" || !text.trim()) return "Thinking";
+  var lines = text.split("\n");
+  var heading = "";
+  for (var i = 0; i < lines.length; i++) {
+    if (/^\s*(?:#{1,6}\s+|\*\*|__)/.test(lines[i])) {
+      var candidate = plainText(lines[i]);
+      if (candidate) heading = candidate;
+    }
+  }
+  var paragraphs = text.trim().split(/\n\s*\n/);
+  var summary = heading || plainText(paragraphs[paragraphs.length - 1]);
+  if (!heading) {
+    var sentence = summary.match(/^.*?[.!?。！？](?:\s|$)/);
+    if (sentence) summary = sentence[0].trim();
+  }
+  if (!summary) return "Thinking";
+  return summary.length > 140 ? summary.slice(0, 139).trimEnd() + "…" : summary;
+}

package/lib/public/modules/thinking-view.js

@@ -0,0 +1,75 @@
+import { thinkingSummary } from './thinking-summary.js';
+import { renderMarkdown } from './markdown.js';
+
+export function prepareThinkingView(el) {
+  el.hidden = false;
+  el.classList.remove("empty", "done", "expanded", "thinking-live");
+  var header = el.querySelector(".thinking-header");
+  header.setAttribute("role", "button");
+  header.setAttribute("aria-expanded", "false");
+  header.setAttribute("aria-disabled", "true");
+  header.tabIndex = -1;
+  header.style.cursor = "";
+  el.querySelector(".thinking-chevron").style.display = "";
+  el.querySelector(".thinking-label").textContent = "Thinking";
+  el.querySelector(".thinking-label").removeAttribute("title");
+  el.querySelector(".thinking-duration").textContent = "";
+  el.querySelector(".thinking-content").textContent = "";
+}
+
+export function bindThinkingView(el) {
+  var header = el.querySelector(".thinking-header");
+  function toggle() {
+    if (header.getAttribute("aria-disabled") === "true") return;
+    el.classList.toggle("expanded");
+    header.setAttribute("aria-expanded", el.classList.contains("expanded") ? "true" : "false");
+  }
+  header.addEventListener("click", toggle);
+  header.addEventListener("keydown", function (event) {
+    if (event.key !== "Enter" && event.key !== " ") return;
+    event.preventDefault();
+    toggle();
+  });
+}
+
+export function updateThinkingView(el, summaryText, detailsText) {
+  var summary = thinkingSummary(summaryText);
+  var label = el.querySelector(".thinking-label");
+  label.textContent = summary;
+  label.title = summary;
+  el.querySelector(".thinking-content").innerHTML = detailsText.trim() ? renderMarkdown(detailsText) : "";
+}
+
+export function setThinkingViewLive(el, live) {
+  el.classList.toggle("thinking-live", !!live);
+}
+
+export function beginThinkingView(el, shimmer) {
+  el.hidden = false;
+  el.classList.remove("done", "empty", "expanded");
+  setThinkingViewLive(el, shimmer);
+  var header = el.querySelector(".thinking-header");
+  header.setAttribute("aria-expanded", "false");
+  header.setAttribute("aria-disabled", "true");
+  header.tabIndex = -1;
+  header.style.cursor = "";
+  el.querySelector(".thinking-chevron").style.display = "";
+}
+
+export function finishThinkingView(el, summaryText, detailsText) {
+  el.classList.remove("thinking-live");
+  el.classList.add("done");
+  el.classList.remove("expanded");
+  updateThinkingView(el, summaryText, detailsText);
+  var hasContent = !!detailsText.trim();
+  var header = el.querySelector(".thinking-header");
+  header.setAttribute("aria-expanded", "false");
+  header.setAttribute("aria-disabled", hasContent ? "false" : "true");
+  header.tabIndex = hasContent ? 0 : -1;
+  header.style.cursor = hasContent ? "pointer" : "default";
+  el.hidden = !hasContent;
+  if (!hasContent) {
+    el.classList.add("empty");
+    el.querySelector(".thinking-chevron").style.display = "none";
+  }
+}

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;
+}