@yeaft/webchat-agent 0.1.935 → 0.1.937

package/yeaft/tools/registry.js

@@ -11,6 +11,27 @@
 
 import { formatSize } from '../archive/tool-results.js';
 
+/**
+ * Collaboration tools are mutually exclusive per Yeaft group shape:
+ * single-VP groups use sub-agents; multi-VP groups use VP-to-VP forwarding.
+ * Keep the policy names close to the tool registry so LLM exposure and
+ * execution gating use the same source of truth.
+ */
+export const COLLAB_TOOL_POLICY = Object.freeze({
+  SINGLE_VP: 'single-vp',
+  MULTI_VP: 'multi-vp',
+});
+
+export const SUB_AGENT_TOOL_NAMES = Object.freeze([
+  'SpawnAgent',
+  'PromptAgent',
+  'WaitAgent',
+  'CloseAgent',
+  'ListAgents',
+]);
+
+export const FORWARD_TOOL_NAMES = Object.freeze(['RouteForward']);
+
 /**
  * Per-tool-result hard cap.
  *
@@ -208,6 +229,20 @@ function runWithTimeout(promise, timeoutMs, toolName) {
   });
 }
 
+export function normalizeCollabToolPolicy(policy) {
+  if (policy === COLLAB_TOOL_POLICY.SINGLE_VP || policy === COLLAB_TOOL_POLICY.MULTI_VP) {
+    return policy;
+  }
+  return null;
+}
+
+export function isToolHiddenByCollabPolicy(toolName, policy) {
+  const normalized = normalizeCollabToolPolicy(policy);
+  if (!normalized) return false;
+  if (normalized === COLLAB_TOOL_POLICY.SINGLE_VP) return FORWARD_TOOL_NAMES.includes(toolName);
+  return SUB_AGENT_TOOL_NAMES.includes(toolName);
+}
+
 export class ToolRegistry {
   /** @type {Map<string, import('./types.js').ToolDef>} */
   #tools = new Map();
@@ -293,17 +328,36 @@ export class ToolRegistry {
 
   /**
    * Get tool definitions for the LLM adapter.
-   * Returns all registered tools — mode filtering was removed in task-297.
+   * Returns all registered tools unless a collaboration policy hides one of
+   * the mutually-exclusive orchestration tool families.
    * @param {string} [language='en']
+   * @param {{ collabToolPolicy?: string }} [opts]
    * @returns {{ name: string, description: string, parameters: object }[]}
    */
-  getToolDefs(language = 'en') {
+  getToolDefs(language = 'en', opts = {}) {
     const lang = normalizeLanguage(language);
-    return this.getAllTools().map(t => ({
-      name: t.name,
-      description: localizeVisibleText(t.description, lang, t.name),
-      parameters: localizeParameters(t.parameters, lang, t.name),
-    }));
+    const collabToolPolicy = normalizeCollabToolPolicy(opts?.collabToolPolicy);
+    return this.getAllTools()
+      .filter(t => !isToolHiddenByCollabPolicy(t.name, collabToolPolicy))
+      .map(t => ({
+        name: t.name,
+        description: localizeVisibleText(t.description, lang, t.name),
+        parameters: localizeParameters(t.parameters, lang, t.name),
+      }));
+  }
+
+  /**
+   * Check whether a tool may be called under the current collaboration policy.
+   * Unknown / absent policy keeps the historical behavior: all registered
+   * tools remain callable.
+   * @param {string} name
+   * @param {{ collabToolPolicy?: string }} [opts]
+   * @returns {boolean}
+   */
+  isAllowed(name, opts = {}) {
+    const tool = this.#tools.get(name);
+    if (!tool) return false;
+    return !isToolHiddenByCollabPolicy(tool.name, opts?.collabToolPolicy);
   }
 
   /**
@@ -359,6 +413,48 @@ export class ToolRegistry {
   get names() {
     return this.getAllTools().map(t => t.name);
   }
+
+  /**
+   * Hot-swap the flattened MCP tool set.
+   *
+   * Removes every currently registered tool whose canonical name starts
+   * with `mcp__` (the flattened MCP tool naming convention used by
+   * `buildMcpFlattenedTools()`), then re-registers a fresh set built from
+   * the live MCPManager. Called by the MCP web-bridge after a successful
+   * connect/disconnect/reload so the running engine's next turn sees the
+   * new tool catalogue without needing a full session restart.
+   *
+   * Why "starts with `mcp__`": that prefix is the canonical Claude Code
+   * naming for flattened MCP tools. It cleanly distinguishes them from
+   * built-in tools (Bash, FileRead, etc.) and from the legacy meta-tools
+   * (`mcp_list_tools`, `mcp_call_tool` — single underscore, NOT removed
+   * here) which a caller may still opt into.
+   *
+   * @param {import('../mcp.js').MCPManager} mcpManager
+   * @param {(mgr: import('../mcp.js').MCPManager) => import('./types.js').ToolDef[]} buildFlattened
+   *   — the builder from `./mcp-tools.js`. Injected so this registry file
+   *   stays free of circular `import` to mcp-tools.js (mcp-tools imports
+   *   `defineTool` from types.js, which lives alongside this file).
+   * @returns {{ removed: number, added: number }}
+   */
+  replaceMcpTools(mcpManager, buildFlattened) {
+    let removed = 0;
+    for (const name of [...this.#tools.keys()]) {
+      if (name.startsWith('mcp__')) {
+        this.#tools.delete(name);
+        removed += 1;
+      }
+    }
+    let added = 0;
+    if (typeof buildFlattened === 'function' && mcpManager) {
+      const fresh = buildFlattened(mcpManager) || [];
+      for (const tool of fresh) {
+        this.register(tool);
+        added += 1;
+      }
+    }
+    return { removed, added };
+  }
 }
 
 /**

package/yeaft/web-bridge.js

@@ -19,6 +19,7 @@
  */
 
 import { join } from 'node:path';
+import { COLLAB_TOOL_POLICY } from './tools/registry.js';
 import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { buildDreamOutputSnapshot } from './dream/output-snapshot.js';
@@ -65,6 +66,8 @@ import { pairSanitize } from './pair-sanitize.js';
 import { filterSnapshotForVp } from './snapshot-filter.js';
 import { createVpStatusBroker } from './vp-status-broker.js';
 import { classifyThread as defaultClassifyThread, fallbackTitle } from './vp/thread-classifier.js';
+import { listMcpServers, upsertMcpServer, removeMcpServer } from './config-api.js';
+import { buildMcpFlattenedTools } from './tools/mcp-tools.js';
 
 /** @type {import('./session.js').Session | null} */
 let session = null;
@@ -2614,6 +2617,14 @@ async function waitForVpDrivers(_groupId, driverKeys = []) {
  *   `route_forward` can extend `causedBy` chains correctly. Optional only
  *   for pre-707 callers that no longer exist in production.
  */
+function resolveCollabToolPolicy(sessionMeta) {
+  if (!sessionMeta || typeof sessionMeta !== 'object' || !Array.isArray(sessionMeta.roster)) {
+    return null;
+  }
+  const vpCount = new Set(sessionMeta.roster.filter(v => typeof v === 'string' && v.trim())).size;
+  return vpCount > 1 ? COLLAB_TOOL_POLICY.MULTI_VP : COLLAB_TOOL_POLICY.SINGLE_VP;
+}
+
 export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope, threadId = 'main' }) {
   // Read the group meta once and reuse for both defaultVpId fallback and
   // announcement injection. Each .getMeta() reload reads + parses the
@@ -2654,6 +2665,8 @@ export function buildVpQueryOpts({ vpId, sessionCoordinator, sessionId, envelope
   if (typeof sessionId === 'string' && sessionId.trim()) {
     out.sessionId = sessionId.trim();
   }
+  const collabToolPolicy = resolveCollabToolPolicy(sessionMeta);
+  if (collabToolPolicy) out.collabToolPolicy = collabToolPolicy;
   // task-334-group-editor: surface the group announcement to the engine so
   // buildWorkerPrompt can inject it as a CLAUDE.md-style shared prefix.
   // Empty/missing reads as '' and prompts.js skips the section.
@@ -4186,3 +4199,233 @@ export async function resetYeaftSession() {
     console.error('[Yeaft] Failed to re-initialize session after reset:', err.message);
   }
 }
+
+// ────────────────────────────────────────────────────────────
+// MCP CRUD wire handlers (Claude-Code-style Settings → MCP tab)
+//
+// Wire types: `yeaft_mcp_list` / `yeaft_mcp_add` / `yeaft_mcp_remove` /
+// `yeaft_mcp_reload`. Each:
+//   1. Reads / writes ~/.yeaft/config.json `mcpServers` via config-api.
+//   2. Calls `session.mcpManager.connect|disconnect` to apply at runtime.
+//   3. Hot-swaps the live `toolRegistry` via `replaceMcpTools(...)` so the
+//      next LLM turn sees the new tool catalogue WITHOUT a session restart.
+//   4. Broadcasts `yeaft_mcp_updated` so any subscribed web client (the
+//      Settings panel + any open Yeaft view) refreshes its badge without
+//      a manual reload.
+//
+// The handlers do NOT block on `ensureSessionLoaded()` — the session may
+// not yet be initialised when the user opens Settings before sending the
+// first message. In that case `session` is null and we operate ONLY on
+// the on-disk config; the live runtime takes effect on the next session
+// boot. When `session` IS available, we apply the runtime change too.
+//
+// Wire shape per response: always `{ type: 'yeaft_mcp_*', servers, runtime?, error? }`.
+// Frontend reducer should treat `error` as a non-empty string failure.
+// ────────────────────────────────────────────────────────────
+
+/**
+ * Snapshot the live MCP runtime so the UI can render per-server
+ * connection state next to the configured servers. Safe to call when
+ * the session hasn't been initialised yet — returns an empty runtime.
+ */
+function mcpRuntimeSnapshot() {
+  if (!session?.mcpManager) {
+    return { connected: false, toolCount: 0, perServer: [] };
+  }
+  const status = session.mcpManager.status() || [];
+  const toolCount = typeof session.mcpManager.toolCount === 'number'
+    ? session.mcpManager.toolCount
+    : status.reduce((sum, s) => sum + (s.toolCount || 0), 0);
+  return {
+    connected: !!session.mcpManager.hasServers,
+    toolCount,
+    perServer: status.map(s => ({
+      name: s.name,
+      ready: !!s.ready,
+      toolCount: s.toolCount || 0,
+    })),
+  };
+}
+
+/**
+ * Re-flatten MCP tools into the live ToolRegistry. No-op when the session
+ * (or its registry) hasn't been created yet — the next session boot will
+ * pick up the change.
+ */
+function hotSwapMcpTools() {
+  if (!session?.toolRegistry || typeof session.toolRegistry.replaceMcpTools !== 'function') {
+    return { removed: 0, added: 0, skipped: true };
+  }
+  try {
+    const result = session.toolRegistry.replaceMcpTools(session.mcpManager, buildMcpFlattenedTools);
+    return { ...result, skipped: false };
+  } catch (err) {
+    console.warn('[Yeaft] hot-swap MCP tools failed:', err?.message || err);
+    return { removed: 0, added: 0, skipped: true, error: err?.message || String(err) };
+  }
+}
+
+/**
+ * Broadcast a `yeaft_mcp_updated` event so any client subscribed to the
+ * Yeaft view (Settings panel, status badge) refreshes without needing
+ * to re-open the panel. The current list+runtime are included so the UI
+ * is single-source (no separate fetch round-trip needed).
+ */
+function broadcastMcpUpdated(extra = {}) {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  const listed = listMcpServers(yeaftDir);
+  sendToServer({
+    type: 'yeaft_mcp_updated',
+    servers: listed.servers || [],
+    runtime: mcpRuntimeSnapshot(),
+    ...extra,
+  });
+}
+
+export function handleYeaftMcpList(msg = {}) {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  const listed = listMcpServers(yeaftDir);
+  sendToServer({
+    type: 'yeaft_mcp_list_result',
+    requestId: msg.requestId || null,
+    servers: listed.servers || [],
+    runtime: mcpRuntimeSnapshot(),
+    error: listed.error || null,
+  });
+}
+
+export async function handleYeaftMcpAdd(msg = {}) {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  const result = upsertMcpServer(msg.server || {}, yeaftDir);
+  if (result.error) {
+    sendToServer({
+      type: 'yeaft_mcp_add_result',
+      requestId: msg.requestId || null,
+      servers: [],
+      runtime: mcpRuntimeSnapshot(),
+      error: result.error,
+    });
+    return;
+  }
+
+  // Apply at runtime when the session is live. The MCPManager's
+  // `connect(serverConfig)` already disconnects-and-reconnects if a
+  // server with the same name was already registered.
+  let connectError = null;
+  if (session?.mcpManager) {
+    try {
+      await session.mcpManager.connect(result.server);
+    } catch (err) {
+      connectError = err?.message || String(err);
+      console.warn(`[Yeaft] MCP connect "${result.server.name}" failed:`, connectError);
+    }
+  }
+
+  const swap = hotSwapMcpTools();
+
+  sendToServer({
+    type: 'yeaft_mcp_add_result',
+    requestId: msg.requestId || null,
+    servers: result.servers,
+    runtime: mcpRuntimeSnapshot(),
+    swap,
+    connectError,
+    error: null,
+  });
+  broadcastMcpUpdated({ reason: 'add', name: result.server.name, connectError });
+}
+
+export async function handleYeaftMcpRemove(msg = {}) {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  const name = typeof msg.name === 'string' ? msg.name : '';
+  const result = removeMcpServer(name, yeaftDir);
+  if (result.error) {
+    sendToServer({
+      type: 'yeaft_mcp_remove_result',
+      requestId: msg.requestId || null,
+      servers: [],
+      runtime: mcpRuntimeSnapshot(),
+      error: result.error,
+    });
+    return;
+  }
+
+  if (session?.mcpManager) {
+    try {
+      await session.mcpManager.disconnect(name);
+    } catch (err) {
+      console.warn(`[Yeaft] MCP disconnect "${name}" failed:`, err?.message || err);
+    }
+  }
+
+  const swap = hotSwapMcpTools();
+
+  sendToServer({
+    type: 'yeaft_mcp_remove_result',
+    requestId: msg.requestId || null,
+    servers: result.servers,
+    runtime: mcpRuntimeSnapshot(),
+    removed: !!result.removed,
+    swap,
+    error: null,
+  });
+  broadcastMcpUpdated({ reason: 'remove', name });
+}
+
+export async function handleYeaftMcpReload(msg = {}) {
+  const yeaftDir = ctx.CONFIG?.yeaftDir;
+  const targetName = typeof msg.name === 'string' && msg.name ? msg.name : null;
+
+  if (!session?.mcpManager) {
+    // Session not yet alive — just echo the current config + an empty
+    // runtime so the UI knows to wait for session boot.
+    const listed = listMcpServers(yeaftDir);
+    sendToServer({
+      type: 'yeaft_mcp_reload_result',
+      requestId: msg.requestId || null,
+      servers: listed.servers || [],
+      runtime: mcpRuntimeSnapshot(),
+      error: null,
+    });
+    return;
+  }
+
+  const listed = listMcpServers(yeaftDir);
+  const configured = listed.servers || [];
+
+  // Per-server reload: disconnect + reconnect the named server only.
+  // Whole-set reload: disconnect everything, then reconnect from current
+  // config.json. The latter is what the user clicks "Reload all" for.
+  const failures = [];
+  try {
+    if (targetName) {
+      const cfg = configured.find(s => s.name === targetName);
+      try { await session.mcpManager.disconnect(targetName); } catch { /* ignore */ }
+      if (cfg) {
+        try { await session.mcpManager.connect(cfg); }
+        catch (err) { failures.push({ name: targetName, error: err?.message || String(err) }); }
+      }
+    } else {
+      try { await session.mcpManager.disconnectAll(); } catch { /* ignore */ }
+      for (const cfg of configured) {
+        try { await session.mcpManager.connect(cfg); }
+        catch (err) { failures.push({ name: cfg.name, error: err?.message || String(err) }); }
+      }
+    }
+  } catch (err) {
+    console.warn('[Yeaft] MCP reload failed:', err?.message || err);
+  }
+
+  const swap = hotSwapMcpTools();
+
+  sendToServer({
+    type: 'yeaft_mcp_reload_result',
+    requestId: msg.requestId || null,
+    servers: configured,
+    runtime: mcpRuntimeSnapshot(),
+    failures,
+    swap,
+    error: null,
+  });
+  broadcastMcpUpdated({ reason: 'reload', name: targetName, failures });
+}