@humain/terminal 0.0.3-beta.0 → 0.0.3-beta.2

package/dist/humain/mcp-adapter/vendor/index.bundle.mjs

@@ -205,6 +205,14 @@ function globToRegExp(pattern) {
   const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`);
 }
+function createToolSelectorCandidateIndex(allCurrentCandidates, additionalCurrentCandidatesByToolName) {
+  return {
+    allCurrentCandidates,
+    matchingCountByPattern: /* @__PURE__ */ new Map(),
+    matcherByPattern: /* @__PURE__ */ new Map(),
+    ...additionalCurrentCandidatesByToolName ? { additionalCurrentCandidatesByToolName } : {}
+  };
+}
 function matchesToolPattern(candidates, patterns) {
   if (!Array.isArray(patterns) || patterns.length === 0) return false;
   for (const pattern of patterns) {
@@ -218,16 +226,51 @@ function matchesToolPattern(candidates, patterns) {
   }
   return false;
 }
+function indexHasOtherCurrentMatch(index, toolName, currentCandidates, pattern) {
+  const additionalCandidates = index.additionalCurrentCandidatesByToolName?.get(toolName);
+  const hasCandidate = (candidate) => index.allCurrentCandidates.has(candidate) || additionalCandidates?.has(candidate) === true;
+  const isGlob = pattern.includes("*") || pattern.includes("?");
+  if (!isGlob) {
+    return hasCandidate(pattern) && !currentCandidates.has(pattern);
+  }
+  let matcher = index.matcherByPattern.get(pattern);
+  if (!matcher) {
+    matcher = globToRegExp(pattern);
+    index.matcherByPattern.set(pattern, matcher);
+  }
+  let matchingCount = index.matchingCountByPattern.get(pattern);
+  if (matchingCount === void 0) {
+    matchingCount = 0;
+    for (const candidate of index.allCurrentCandidates) {
+      if (matcher.test(candidate)) matchingCount++;
+    }
+    index.matchingCountByPattern.set(pattern, matchingCount);
+  }
+  let totalMatchingCount = matchingCount;
+  if (additionalCandidates) {
+    for (const candidate of additionalCandidates) {
+      if (!index.allCurrentCandidates.has(candidate) && matcher.test(candidate)) totalMatchingCount++;
+    }
+  }
+  if (totalMatchingCount === 0) return false;
+  let currentMatchingCount = 0;
+  for (const candidate of currentCandidates) {
+    if (hasCandidate(candidate) && matcher.test(candidate)) currentMatchingCount++;
+  }
+  return totalMatchingCount > currentMatchingCount;
+}
 function matchesToolSelector(toolName, serverName, prefix, patterns, otherCurrentCandidates) {
+  if (!Array.isArray(patterns) || patterns.length === 0) return false;
   const currentCandidates = getToolNameCandidates(toolName, serverName, prefix, false);
   if (matchesToolPattern(currentCandidates, patterns)) return true;
   if (!otherCurrentCandidates) return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), patterns);
   const legacyCandidates = getToolNameCandidates(toolName, serverName, prefix);
   for (const candidate of currentCandidates) legacyCandidates.delete(candidate);
-  if (!Array.isArray(patterns)) return false;
-  return patterns.some(
-    (pattern) => typeof pattern === "string" && !matchesToolPattern(otherCurrentCandidates, [pattern]) && matchesToolPattern(legacyCandidates, [pattern])
-  );
+  return patterns.some((pattern) => {
+    if (typeof pattern !== "string" || !matchesToolPattern(legacyCandidates, [pattern])) return false;
+    const hasCollision = otherCurrentCandidates instanceof Set ? matchesToolPattern(otherCurrentCandidates, [pattern]) : indexHasOtherCurrentMatch(otherCurrentCandidates, toolName, currentCandidates, pattern);
+    return !hasCollision;
+  });
 }
 function isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates) {
   if (!Array.isArray(includeTools) || includeTools.length === 0) return true;
@@ -254,10 +297,17 @@ var init_types = __esm({
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+function getConfigDirName() {
+  const configDir = readPiConfig()?.configDir;
+  return typeof configDir === "string" && configDir.trim() ? configDir.trim() : ".pi";
+}
 function getAgentDir() {
-  const configured = process.env.PI_CODING_AGENT_DIR?.trim();
+  const piConfig = readPiConfig();
+  const name = piConfig?.name;
+  const appName = typeof name === "string" && name.trim() ? name.trim() : "pi";
+  const configured = process.env[`${appName.toUpperCase()}_CODING_AGENT_DIR`]?.trim();
   if (!configured) {
-    return join(homedir(), ".pi", "agent");
+    return join(homedir(), getConfigDirName(), "agent");
   }
   if (configured === "~") {
     return homedir();
@@ -859,7 +909,7 @@ function getProjectConfigPath(cwd = process.cwd()) {
   return resolve3(cwd, PROJECT_CONFIG_NAME);
 }
 function getProjectPiConfigPath(cwd = process.cwd()) {
-  return resolve3(cwd, PROJECT_PI_CONFIG_NAME);
+  return resolve3(cwd, getConfigDirName(), PROJECT_PI_CONFIG_NAME);
 }
 function getConfigSourceSummaries(sourceSpecs) {
   return sourceSpecs.map((source) => {
@@ -1706,7 +1756,7 @@ var init_config = __esm({
       join3(homedir3(), ".agents", "mcp", "mcp.json")
     ];
     PROJECT_CONFIG_NAME = ".mcp.json";
-    PROJECT_PI_CONFIG_NAME = ".pi/mcp.json";
+    PROJECT_PI_CONFIG_NAME = "mcp.json";
     REPOPROMPT_BINARY_CANDIDATES = [
       join3(homedir3(), "RepoPrompt", "repoprompt_cli"),
       "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp"
@@ -1762,7 +1812,7 @@ var init_config = __esm({
       windsurf: [join3(homedir3(), ".windsurf", "mcp.json")],
       vscode: [".vscode/mcp.json"]
     };
-    URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv"];
+    URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv", "requestHeadersCommand"];
   }
 });
 
@@ -1894,6 +1944,12 @@ function computeServerHash(definition) {
     cwd: resolveConfigPath(definition.cwd),
     url: resolveServerUrl(definition),
     headers: interpolateEnvRecord(definition.headers),
+    requestHeadersCommand: definition.requestHeadersCommand ? {
+      command: interpolateEnvVars(definition.requestHeadersCommand.command),
+      args: definition.requestHeadersCommand.args?.map(interpolateEnvVars),
+      env: interpolateEnvRecord(definition.requestHeadersCommand.env),
+      timeoutMs: definition.requestHeadersCommand.timeoutMs
+    } : void 0,
     auth: definition.auth,
     protocolVersion: definition.protocolVersion,
     bearerToken: resolveBearerToken(definition),
@@ -1956,8 +2012,8 @@ function reconstructToolMetadata(serverName, entry, prefix, definition, configur
   const metadata = [];
   const seenNames = /* @__PURE__ */ new Set();
   const effectivePrefix = resolveToolPrefix(definition, prefix);
-  const getOtherCurrentCandidates = (toolName) => {
-    if (!configuredServers || !cache) return void 0;
+  const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+  const selectorCandidateIndex = hasToolFilters && configuredServers && cache ? (() => {
     const candidates = /* @__PURE__ */ new Set();
     for (const [otherServerName, otherDefinition] of Object.entries(configuredServers)) {
       const otherEntry = cache.servers[otherServerName];
@@ -1974,15 +2030,14 @@ function reconstructToolMetadata(serverName, entry, prefix, definition, configur
         }
       }
     }
-    for (const candidate of getToolNameCandidates(toolName, serverName, effectivePrefix, false)) candidates.delete(candidate);
-    return candidates;
-  };
+    return createToolSelectorCandidateIndex(candidates);
+  })() : void 0;
   for (const tool of entry.tools ?? []) {
     if (!tool?.name) continue;
     if (!isUiToolVisibleToModel(tool.uiVisibility)) {
       continue;
     }
-    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(tool.name))) {
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
       continue;
     }
     const name = formatToolName(tool.name, serverName, effectivePrefix);
@@ -2004,7 +2059,7 @@ function reconstructToolMetadata(serverName, entry, prefix, definition, configur
     for (const resource of entry.resources ?? []) {
       if (!resource?.name || !resource?.uri) continue;
       const baseName = `read_${resourceNameToToolName(resource.name)}`;
-      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(baseName))) {
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
         continue;
       }
       const name = formatToolName(baseName, serverName, effectivePrefix);
@@ -2177,6 +2232,7 @@ var init_mcp_setup_panel = __esm({
   "packages/coding-agent/src/humain/mcp-adapter/vendor/mcp-setup-panel.ts"() {
     "use strict";
     init_panel_keys();
+    init_agent_dir();
     init_config();
     DEFAULT_THEME = {
       border: "2",
@@ -2607,7 +2663,7 @@ var init_mcp_setup_panel = __esm({
               "3. ~/.agents/mcp/mcp.json",
               "4. <Pi agent dir>/mcp.json",
               "5. .mcp.json",
-              "6. .pi/mcp.json",
+              `6. ${getConfigDirName()}/mcp.json`,
               `Host discovery: ${this.discovery.hostConfigDiscovery}. Conflicts reported: ${this.discovery.conflicts.length}.`,
               ...this.discovery.conflicts.slice(0, 8).map(
                 (conflict) => `${conflict.serverName}: ${conflict.sources.map((source) => source.path).join(" -> ")} (winner: ${conflict.winner.path})`
@@ -2752,7 +2808,7 @@ var init_clipboard_image = __esm({
 });
 
 // packages/coding-agent/src/utils/clipboard.ts
-import { execFileSync, execSync, spawn } from "child_process";
+import { execFileSync, execSync, spawn as spawn2 } from "child_process";
 import { platform as platform2 } from "os";
 function copyToX11Clipboard(options) {
   try {
@@ -2811,7 +2867,7 @@ async function copyToClipboard(text) {
             try {
               execSync("which wl-copy", { stdio: "ignore" });
               const wlCopyExit = await new Promise((resolve6) => {
-                const proc = spawn("wl-copy", [], { stdio: ["pipe", "ignore", "ignore"] });
+                const proc = spawn2("wl-copy", [], { stdio: ["pipe", "ignore", "ignore"] });
                 proc.on("error", () => resolve6(1));
                 proc.on("close", (code) => resolve6(code ?? 1));
                 proc.stdin.on("error", () => {
@@ -7681,6 +7737,292 @@ function traceTransportKind(definition, transport) {
   return definition.url ? "streamable-http" : "unknown";
 }
 
+// packages/coding-agent/src/humain/mcp-adapter/vendor/request-headers-command.ts
+init_utils();
+import { spawn, spawnSync as spawnSync3 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_OUTPUT_BYTES = 64 * 1024;
+var USE_PROCESS_GROUP = process.platform !== "win32";
+var CLEANUP_TOKEN_ENV = "PI_MCP_REQUEST_HEADERS_CLEANUP_TOKEN";
+function isNoSuchProcessError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+}
+function runPosixPs(args) {
+  if (process.env.PI_MCP_ADAPTER_TEST_FAIL_PS === "1") return { status: 1, stdout: "" };
+  return spawnSync3("ps", args, { encoding: "utf8" });
+}
+function collectPosixDescendantPids(rootPid) {
+  const result = runPosixPs(["-axo", "pid=,ppid="]);
+  if (result.status !== 0) {
+    throw new Error(`HTTP request headers command cleanup failed: ps exited with code ${result.status ?? "unknown"}`);
+  }
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const line of result.stdout.split("\n")) {
+    const [pidText, ppidText] = line.trim().split(/\s+/, 2);
+    const pid = Number(pidText);
+    const ppid = Number(ppidText);
+    if (!Number.isInteger(pid) || !Number.isInteger(ppid)) continue;
+    const children = childrenByParent.get(ppid);
+    if (children) children.push(pid);
+    else childrenByParent.set(ppid, [pid]);
+  }
+  const descendants = [];
+  const stack = [...childrenByParent.get(rootPid) ?? []];
+  while (stack.length > 0) {
+    const pid = stack.pop();
+    descendants.push(pid);
+    stack.push(...childrenByParent.get(pid) ?? []);
+  }
+  return descendants;
+}
+function collectPosixCleanupTokenPids(cleanupToken) {
+  const result = runPosixPs(["axeww", "-o", "pid=,command="]);
+  if (result.status !== 0) {
+    throw new Error(`HTTP request headers command cleanup failed: ps exited with code ${result.status ?? "unknown"}`);
+  }
+  const needle = `${CLEANUP_TOKEN_ENV}=${cleanupToken}`;
+  const pids = [];
+  for (const line of result.stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.includes(needle)) continue;
+    const [pidText] = trimmed.split(/\s+/, 1);
+    const pid = Number(pidText);
+    if (Number.isInteger(pid) && pid !== process.pid) pids.push(pid);
+  }
+  return pids;
+}
+function assertPosixProcessDiscoveryAvailable() {
+  collectPosixDescendantPids(process.pid);
+  collectPosixCleanupTokenPids(`${process.pid}-preflight`);
+}
+function isTaskkillNoSuchProcess(result) {
+  return `${result.stdout ?? ""}
+${result.stderr ?? ""}`.toLowerCase().includes("not found");
+}
+function signalPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (!isNoSuchProcessError(error)) throw error;
+  }
+}
+function signalProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (!isNoSuchProcessError(error)) throw error;
+  }
+}
+function killRequestHeadersCommand(child, trackedPosixDescendantPids = /* @__PURE__ */ new Set(), cleanupToken) {
+  if (process.platform === "win32" && child.pid !== void 0) {
+    const result = spawnSync3("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (result.status === 0 || isTaskkillNoSuchProcess(result)) return;
+    throw new Error(`HTTP request headers command cleanup failed: taskkill exited with code ${result.status ?? "unknown"}`);
+  }
+  if (USE_PROCESS_GROUP && child.pid !== void 0) {
+    const frozenPids = /* @__PURE__ */ new Set();
+    let cleanupError;
+    try {
+      signalProcessGroup(child.pid, "SIGSTOP");
+      for (const pid of trackedPosixDescendantPids) {
+        signalPid(pid, "SIGSTOP");
+        frozenPids.add(pid);
+      }
+      let stablePasses = 0;
+      for (let pass = 0; pass < 16; pass++) {
+        const candidates = [
+          ...collectPosixDescendantPids(child.pid),
+          ...cleanupToken ? collectPosixCleanupTokenPids(cleanupToken) : []
+        ];
+        const newPids = candidates.filter((pid) => !frozenPids.has(pid));
+        if (newPids.length === 0) {
+          stablePasses++;
+          if (stablePasses >= 2) return;
+          continue;
+        }
+        stablePasses = 0;
+        for (const pid of newPids) {
+          signalPid(pid, "SIGSTOP");
+          frozenPids.add(pid);
+        }
+      }
+      cleanupError = new Error("HTTP request headers command cleanup failed: descendant process tree did not stabilize");
+    } catch (error) {
+      cleanupError = error instanceof Error ? error : new Error(String(error));
+    } finally {
+      signalProcessGroup(child.pid, "SIGKILL");
+      for (const pid of frozenPids) signalPid(pid, "SIGKILL");
+    }
+    if (cleanupError) throw cleanupError;
+    return;
+  }
+  child.kill("SIGKILL");
+}
+function resolvedCommand(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("HTTP request headers command must be an object");
+  }
+  if (typeof config.command !== "string" || config.command.trim() === "") {
+    throw new Error("HTTP request headers command requires a non-empty command");
+  }
+  if (config.args !== void 0 && (!Array.isArray(config.args) || config.args.some((arg) => typeof arg !== "string"))) {
+    throw new Error("HTTP request headers command args must be strings");
+  }
+  if (config.env !== void 0 && (typeof config.env !== "object" || Array.isArray(config.env) || Object.values(config.env).some((value) => typeof value !== "string"))) {
+    throw new Error("HTTP request headers command env values must be strings");
+  }
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 6e4) {
+    throw new Error("HTTP request headers command timeoutMs must be an integer between 1 and 60000");
+  }
+  return {
+    command: interpolateEnvVars(config.command),
+    args: (config.args ?? []).map(interpolateEnvVars),
+    env: {
+      ...process.env,
+      ...Object.fromEntries(
+        Object.entries(config.env ?? {}).map(([key, value]) => [key, interpolateEnvVars(value)])
+      )
+    },
+    timeoutMs
+  };
+}
+async function invokeRequestHeadersCommand(config, envelope, signal) {
+  const resolved = resolvedCommand(config);
+  if (USE_PROCESS_GROUP) assertPosixProcessDiscoveryAvailable();
+  return new Promise((resolve6, reject) => {
+    let stdout = Buffer.alloc(0);
+    let settled = false;
+    const cleanupToken = randomUUID();
+    const child = spawn(resolved.command, resolved.args, {
+      env: { ...resolved.env, [CLEANUP_TOKEN_ENV]: cleanupToken },
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true,
+      detached: USE_PROCESS_GROUP
+    });
+    const trackedPosixDescendantPids = /* @__PURE__ */ new Set();
+    let trackingError;
+    const trackPosixDescendants = () => {
+      if (!USE_PROCESS_GROUP || child.pid === void 0 || settled || trackingError) return;
+      try {
+        for (const pid of collectPosixDescendantPids(child.pid)) trackedPosixDescendantPids.add(pid);
+        for (const pid of collectPosixCleanupTokenPids(cleanupToken)) trackedPosixDescendantPids.add(pid);
+      } catch (error) {
+        trackingError = error instanceof Error ? error : new Error(String(error));
+      }
+    };
+    const descendantTracker = USE_PROCESS_GROUP ? setInterval(trackPosixDescendants, 50) : void 0;
+    descendantTracker?.unref();
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (descendantTracker) clearInterval(descendantTracker);
+      signal.removeEventListener("abort", abort);
+      if (result.status === "error") reject(result.error);
+      else resolve6(result.headers);
+    };
+    const finishAfterKill = (result) => {
+      try {
+        killRequestHeadersCommand(child, trackedPosixDescendantPids, cleanupToken);
+        finish(result);
+      } catch (cleanupError) {
+        finish({ status: "error", error: cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)) });
+      }
+    };
+    const failAfterKill = (message) => {
+      finishAfterKill({ status: "error", error: trackingError ?? new Error(message) });
+    };
+    const abort = () => {
+      failAfterKill("HTTP request headers command aborted");
+    };
+    const timer = setTimeout(() => {
+      failAfterKill(`HTTP request headers command timed out after ${resolved.timeoutMs}ms`);
+    }, resolved.timeoutMs);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    child.on("error", () => finish({ status: "error", error: new Error("HTTP request headers command failed to start") }));
+    child.stdout.on("data", (chunk) => {
+      if (settled) return;
+      stdout = Buffer.concat([stdout, Buffer.from(chunk)]);
+      if (stdout.byteLength > MAX_OUTPUT_BYTES) {
+        failAfterKill("HTTP request headers command output exceeded 64 KiB");
+      }
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      if (trackingError) {
+        failAfterKill(trackingError.message);
+        return;
+      }
+      if (code !== 0) {
+        failAfterKill(`HTTP request headers command exited with code ${code ?? "unknown"}`);
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout.toString("utf8"));
+      } catch {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command returned invalid JSON") });
+        return;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command must return a JSON object") });
+        return;
+      }
+      const entries = Object.entries(parsed);
+      if (entries.some(([, value]) => typeof value !== "string")) {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command values must be strings") });
+        return;
+      }
+      try {
+        finishAfterKill({ status: "success", headers: new Headers(entries) });
+      } catch {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command returned an invalid header") });
+      }
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(JSON.stringify(envelope));
+  });
+}
+function createRequestHeadersCommandFetch(config, delegate = globalThis.fetch) {
+  resolvedCommand(config);
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const body = Buffer.from(await request.clone().arrayBuffer());
+    const derived = await invokeRequestHeadersCommand(config, {
+      version: 1,
+      method: request.method.toUpperCase(),
+      url: request.url,
+      bodyBase64: body.toString("base64")
+    }, request.signal);
+    const headers = new Headers(request.headers);
+    derived.forEach((value, name) => headers.set(name, value));
+    return delegate(new URL(request.url), {
+      method: request.method,
+      headers,
+      ...request.method === "GET" || request.method === "HEAD" ? {} : { body },
+      signal: request.signal,
+      cache: request.cache,
+      credentials: request.credentials,
+      integrity: request.integrity,
+      keepalive: request.keepalive,
+      mode: request.mode,
+      redirect: request.redirect,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    });
+  };
+}
+
 // packages/coding-agent/src/humain/mcp-adapter/vendor/server-manager.ts
 var MAX_CAPTURED_STDERR_BYTES = 8 * 1024;
 var MAX_CAPTURED_STDERR_LINES = 3;
@@ -8187,6 +8529,7 @@ var McpServerManager = class {
       }
     }
     const requestInit = Object.keys(headers).length > 0 ? { headers } : void 0;
+    const requestFetch = definition.requestHeadersCommand ? createRequestHeadersCommandFetch(definition.requestHeadersCommand) : void 0;
     const createAuthProvider = () => new McpOAuthProvider(
       serverName,
       serverUrl,
@@ -8201,6 +8544,7 @@ var McpServerManager = class {
       const authProvider = "provider" in authState ? authState.provider : void 0;
       const transportOptions = {
         ...requestInit !== void 0 ? { requestInit } : {},
+        ...requestFetch !== void 0 ? { fetch: requestFetch } : {},
         ...authProvider !== void 0 ? { authProvider } : {},
         ...authProvider !== void 0 && definition.oauth !== false && definition.oauth?.skipIssuerMetadataValidation === true ? { skipIssuerMetadataValidation: true } : {}
       };
@@ -8493,46 +8837,59 @@ function buildToolMetadata(tools, resources, definition, serverName, prefix, con
   const failedTools = [];
   const seenNames = /* @__PURE__ */ new Set();
   const effectivePrefix = resolveToolPrefix(definition, prefix);
-  const getOtherCurrentCandidates = (toolName) => {
-    if (!configuredServers) return void 0;
+  const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+  const selectorCandidateIndex = hasToolFilters && configuredServers ? (() => {
     const candidates = /* @__PURE__ */ new Set();
-    const addCandidates = (originalName, candidateServerName, candidatePrefix) => {
-      for (const candidate of getToolNameCandidates(originalName, candidateServerName, candidatePrefix, false)) candidates.add(candidate);
+    const additionalCandidatesByToolName = /* @__PURE__ */ new Map();
+    const evaluatedToolNames = /* @__PURE__ */ new Set();
+    const addCandidates = (target, originalName, candidateServerName, candidatePrefix) => {
+      for (const candidate of getToolNameCandidates(originalName, candidateServerName, candidatePrefix, false)) target.add(candidate);
     };
     for (const tool of tools) {
-      if (tool?.name) addCandidates(tool.name, serverName, effectivePrefix);
+      if (!tool?.name) continue;
+      evaluatedToolNames.add(tool.name);
+      addCandidates(candidates, tool.name, serverName, effectivePrefix);
     }
     if (definition.exposeResources !== false) {
       for (const resource of resources) {
-        if (resource?.name && resource?.uri) addCandidates(`read_${resourceNameToToolName(resource.name)}`, serverName, effectivePrefix);
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        evaluatedToolNames.add(baseName);
+        if (resource?.name && resource?.uri) addCandidates(candidates, baseName, serverName, effectivePrefix);
       }
     }
     for (const [otherServerName, otherDefinition] of Object.entries(configuredServers)) {
       if (otherServerName === serverName) continue;
+      const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
       const knownTools = knownMetadata?.get(otherServerName);
       if (knownTools) {
-        const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
         for (const tool of knownTools) {
           candidates.add(tool.name);
-          addCandidates(tool.originalName, otherServerName, otherPrefix);
+          addCandidates(candidates, tool.originalName, otherServerName, otherPrefix);
         }
       } else if (!knownMetadata || includeMissingConfiguredCandidates) {
-        const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
-        addCandidates(toolName, otherServerName, otherPrefix);
-        if (includeMissingConfiguredCandidates) {
-          for (const candidate of getToolNameCandidates(toolName, otherServerName, otherPrefix, false)) candidates.add(candidate.replace(/-/g, "_"));
+        for (const toolName of evaluatedToolNames) {
+          let additionalCandidates = additionalCandidatesByToolName.get(toolName);
+          if (!additionalCandidates) {
+            additionalCandidates = /* @__PURE__ */ new Set();
+            additionalCandidatesByToolName.set(toolName, additionalCandidates);
+          }
+          addCandidates(additionalCandidates, toolName, otherServerName, otherPrefix);
+          if (includeMissingConfiguredCandidates) {
+            for (const candidate of getToolNameCandidates(toolName, otherServerName, otherPrefix, false)) {
+              additionalCandidates.add(candidate.replace(/-/g, "_"));
+            }
+          }
         }
       }
     }
-    for (const candidate of getToolNameCandidates(toolName, serverName, effectivePrefix, false)) candidates.delete(candidate);
-    return candidates;
-  };
+    return createToolSelectorCandidateIndex(candidates, additionalCandidatesByToolName);
+  })() : void 0;
   for (const tool of tools) {
     if (!tool?.name) {
       failedTools.push("(unnamed)");
       continue;
     }
-    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(tool.name))) {
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
       continue;
     }
     const name = formatToolName(tool.name, serverName, effectivePrefix);
@@ -8564,7 +8921,7 @@ function buildToolMetadata(tools, resources, definition, serverName, prefix, con
   if (definition.exposeResources !== false) {
     for (const resource of resources) {
       const baseName = `read_${resourceNameToToolName(resource.name)}`;
-      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(baseName))) {
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
         continue;
       }
       const name = formatToolName(baseName, serverName, effectivePrefix);
@@ -10640,7 +10997,7 @@ function formatSize(bytes) {
 // packages/coding-agent/src/humain/mcp-adapter/vendor/ui-session.ts
 init_types();
 import { execFile } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import net from "node:net";
 import { UrlElicitationRequiredError as UrlElicitationRequiredError2 } from "@modelcontextprotocol/client";
 
@@ -10649,7 +11006,7 @@ init_ui_app_bridge_helpers();
 import http from "node:http";
 import fs2 from "node:fs/promises";
 import path from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { ContentBlockSchema } from "@modelcontextprotocol/core";
 init_utils();
 
@@ -11070,7 +11427,7 @@ function escapeHtml2(value) {
 }
 
 // packages/coding-agent/src/humain/mcp-adapter/vendor/tool-approval.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 init_types();
 init_utils();
 function isToolCallApprovalRequired(config, serverName, toolMeta, toolMetadata) {
@@ -11127,7 +11484,7 @@ async function requestBrokerApproval(state, serverName, toolMeta, args, origin,
   let acceptingClaim = true;
   let handler;
   const request = {
-    requestId: randomUUID(),
+    requestId: randomUUID2(),
     serverName,
     originalToolName: toolMeta.originalName,
     prefixedToolName: toolMeta.name,
@@ -11208,8 +11565,8 @@ var MOSHI_DISCOVERY_PORT_START = 8377;
 var MOSHI_DISCOVERY_PORT_END = 8396;
 var nextMoshiDiscoveryPort = MOSHI_DISCOVERY_PORT_START;
 async function startUiServer(options) {
-  const sessionToken = options.sessionToken ?? randomUUID2();
-  const uiResourceToken = randomUUID2();
+  const sessionToken = options.sessionToken ?? randomUUID3();
+  const uiResourceToken = randomUUID3();
   const log = logger.child({
     component: "UiServer",
     server: options.serverName,
@@ -12051,8 +12408,8 @@ async function maybeStartUiSession(state, request) {
     if (state.uiServer && state.uiServer.serverName === request.serverName && state.uiServer.toolName === request.toolName) {
       const existingHandle = state.uiServer;
       const streamMode2 = request.streamMode;
-      const streamId2 = streamMode2 ? randomUUID3() : void 0;
-      const streamToken2 = streamMode2 ? randomUUID3() : void 0;
+      const streamId2 = streamMode2 ? randomUUID4() : void 0;
+      const streamToken2 = streamMode2 ? randomUUID4() : void 0;
       let active2 = true;
       let nextStreamSequence2 = 0;
       const cleanupStreamListener2 = () => {
@@ -12128,8 +12485,8 @@ async function maybeStartUiSession(state, request) {
       activeGlimpseWindow = null;
     }
     const streamMode = request.streamMode;
-    const streamId = streamMode ? randomUUID3() : void 0;
-    const streamToken = streamMode ? randomUUID3() : void 0;
+    const streamId = streamMode ? randomUUID4() : void 0;
+    const streamToken = streamMode ? randomUUID4() : void 0;
     const hostContext = streamMode && streamId ? {
       [UI_STREAM_HOST_CONTEXT_KEY]: {
         mode: streamMode,
@@ -12470,7 +12827,8 @@ function resolveDirectTools(config, cache, prefix, envOverride) {
     }
     if (!toolFilter) continue;
     const effectivePrefix = resolveToolPrefix(definition, prefix);
-    const getOtherCurrentCandidates = (toolName) => {
+    const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+    const selectorCandidateIndex = hasToolFilters ? (() => {
       const candidates = /* @__PURE__ */ new Set();
       for (const [otherServerName, otherDefinition] of Object.entries(config.mcpServers)) {
         const otherCache = cache.servers[otherServerName];
@@ -12487,13 +12845,12 @@ function resolveDirectTools(config, cache, prefix, envOverride) {
           }
         }
       }
-      for (const candidate of getToolNameCandidates(toolName, serverName, effectivePrefix, false)) candidates.delete(candidate);
-      return candidates;
-    };
+      return createToolSelectorCandidateIndex(candidates);
+    })() : void 0;
     for (const tool of serverCache.tools ?? []) {
       if (!isUiToolVisibleToModel(tool.uiVisibility)) continue;
       if (toolFilter !== true && !toolFilter.includes(tool.name)) continue;
-      if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(tool.name))) continue;
+      if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) continue;
       const prefixedName = formatToolName(tool.name, serverName, effectivePrefix);
       if (BUILTIN_NAMES.has(prefixedName)) {
         console.warn(`MCP: skipping direct tool "${prefixedName}" (collides with builtin)`);
@@ -12518,7 +12875,7 @@ function resolveDirectTools(config, cache, prefix, envOverride) {
       for (const resource of serverCache.resources ?? []) {
         const baseName = `read_${resourceNameToToolName(resource.name)}`;
         if (toolFilter !== true && !toolFilter.includes(baseName)) continue;
-        if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(baseName))) continue;
+        if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) continue;
         const prefixedName = formatToolName(baseName, serverName, effectivePrefix);
         if (BUILTIN_NAMES.has(prefixedName)) {
           console.warn(`MCP: skipping direct resource tool "${prefixedName}" (collides with builtin)`);
@@ -12539,7 +12896,7 @@ function resolveDirectTools(config, cache, prefix, envOverride) {
       }
     }
   }
-  if (specs.length >= DIRECT_TOOLS_ADVISORY_THRESHOLD) {
+  if (config.settings?.warnOnLargeDirectTools !== false && specs.length >= DIRECT_TOOLS_ADVISORY_THRESHOLD) {
     console.warn(`MCP: ${specs.length} direct tools resolved. Each direct tool adds prompt context; README guidance recommends targeted sets of 5-20 tools and using the proxy or an explicit string[] when 75+ direct tools would be registered.`);
   }
   return specs;
@@ -12567,8 +12924,8 @@ Direct tools available (call as normal tools): ${parts.join(", ")}
     const cachedEntry = cache?.servers?.[serverName];
     const entry = cachedEntry && isServerCacheValid(cachedEntry, definition) ? cachedEntry : void 0;
     const effectivePrefix = resolveToolPrefix(definition, prefix);
-    const getOtherCurrentCandidates = (toolName) => {
-      if (!cache) return void 0;
+    const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+    const selectorCandidateIndex = hasToolFilters && cache ? (() => {
       const candidates = /* @__PURE__ */ new Set();
       for (const [otherServerName, otherDefinition] of Object.entries(config.mcpServers)) {
         const otherEntry = cache.servers[otherServerName];
@@ -12585,15 +12942,14 @@ Direct tools available (call as normal tools): ${parts.join(", ")}
           }
         }
       }
-      for (const candidate of getToolNameCandidates(toolName, serverName, effectivePrefix, false)) candidates.delete(candidate);
-      return candidates;
-    };
+      return createToolSelectorCandidateIndex(candidates);
+    })() : void 0;
     const toolCount = (entry?.tools ?? []).filter(
-      (tool) => isUiToolVisibleToModel(tool.uiVisibility) && isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(tool.name))
+      (tool) => isUiToolVisibleToModel(tool.uiVisibility) && isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)
     ).length;
     const resourceCount = definition?.exposeResources !== false ? (entry?.resources ?? []).filter((resource) => {
       const baseName = `read_${resourceNameToToolName(resource.name)}`;
-      return isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, getOtherCurrentCandidates(baseName));
+      return isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex);
     }).length : 0;
     const totalItems = toolCount + resourceCount;
     if (totalItems === 0) continue;