@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/proxy-modes-HEEFK4KC.js

@@ -0,0 +1,685 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  guardMcpOutput,
+  guardedMcpDetails,
+  maybeStartUiSession,
+  resolveMcpOutputGuardOptions,
+  resolveMcpResultContent,
+  transformMcpContent
+} from "./chunk-F4VQFJI2.js";
+import {
+  buildToolMetadata,
+  findToolByName,
+  formatSchema,
+  getFailureAgeSeconds,
+  getToolNames,
+  lazyConnect,
+  updateMetadataCache,
+  updateServerMetadata,
+  updateStatusBar
+} from "./chunk-MKKH27PH.js";
+import {
+  abortable,
+  formatAuthRequiredMessage,
+  throwIfAborted,
+  truncateAtWord
+} from "./chunk-VSELYKWU.js";
+import {
+  UrlElicitationRequiredError,
+  authenticate,
+  completeAuthFromInput,
+  startAuth,
+  supportsOAuth
+} from "./chunk-4TLO4PO2.js";
+import "./chunk-4HXHDDCF.js";
+import "./chunk-BI3DHYCN.js";
+import {
+  getServerPrefix,
+  parseUiPromptHandoff
+} from "./chunk-ARC4KOTI.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/proxy-modes.js
+import { checkSync } from "recheck";
+var MAX_REGEX_SEARCH_QUERY_LENGTH = 256, REGEX_SAFETY_CHECK_PARAMS = {
+  attackTimeout: 50,
+  incubationTimeout: 50,
+  timeout: 250
+};
+function getAuthRequiredMessage(state, serverName, defaultMessage = `Server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`) {
+  return formatAuthRequiredMessage(state.config, serverName, defaultMessage);
+}
+function getAuthFailedMessage(state, serverName, message) {
+  return state.config.settings?.authRequiredMessage ? `OAuth authentication failed for "${serverName}": ${message}. ${getAuthRequiredMessage(state, serverName)}` : `OAuth authentication failed for "${serverName}": ${message}. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`;
+}
+function getRedirectPort(authorizationUrl) {
+  try {
+    let redirectUri = new URL(authorizationUrl).searchParams.get("redirect_uri");
+    if (!redirectUri)
+      return;
+    let port = Number.parseInt(new URL(redirectUri).port, 10);
+    return Number.isInteger(port) ? port : void 0;
+  } catch {
+    return;
+  }
+}
+function formatManualAuthInstructions(serverName, authorizationUrl) {
+  let port = getRedirectPort(authorizationUrl), portNote = port ? `
+The redirect URL will use local port ${port}. On a remote server it is expected for that localhost page to fail locally; copy the address bar URL anyway.` : "";
+  return [
+    `MCP OAuth required for "${serverName}".`,
+    "",
+    "Open this URL in your local browser:",
+    "",
+    authorizationUrl,
+    "",
+    "After approving, copy the full redirected localhost URL from your browser address bar and send it back with:",
+    `mcp({ action: "auth-complete", server: "${serverName}", args: '{"redirectUrl":"PASTE_REDIRECT_URL_HERE"}' })`,
+    "",
+    'You can also pass just the `code` query parameter as `args: \'{"code":"PASTE_CODE_HERE"}\'`.',
+    portNote.trimEnd()
+  ].filter(Boolean).join(`
+`);
+}
+async function attemptAutoAuth(state, serverName) {
+  if (state.config.settings?.autoAuth !== !0)
+    return { status: "skipped" };
+  let definition = state.config.mcpServers[serverName];
+  if (!definition || !supportsOAuth(definition) || !definition.url)
+    return { status: "skipped" };
+  let grantType = definition.oauth ? definition.oauth.grantType ?? "authorization_code" : "authorization_code";
+  if (!state.ui && grantType !== "client_credentials")
+    return {
+      status: "failed",
+      message: getAuthRequiredMessage(state, serverName, `Server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`)
+    };
+  try {
+    return await authenticate(serverName, definition.url, definition), { status: "success" };
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      message: getAuthFailedMessage(state, serverName, message)
+    };
+  }
+}
+function executeUiMessages(state) {
+  let sessions = state.completedUiSessions;
+  if (sessions.length === 0)
+    return {
+      content: [{ type: "text", text: "No UI session messages available." }],
+      details: { sessions: 0 }
+    };
+  let output = [];
+  output.push(`UI Session Messages (${sessions.length} session${sessions.length > 1 ? "s" : ""}):
+`);
+  let allPrompts = [], allIntents = sessions.flatMap((session) => session.messages.intents), parsedHandoffs = [];
+  for (let session of sessions) {
+    let timestamp = session.completedAt.toLocaleTimeString();
+    output.push(`
+## ${session.serverName} / ${session.toolName} (${timestamp}, ${session.reason})`);
+    let plainPrompts = [];
+    for (let prompt of session.messages.prompts) {
+      allPrompts.push(prompt);
+      let handoff = parseUiPromptHandoff(prompt);
+      handoff ? parsedHandoffs.push(handoff) : plainPrompts.push(prompt);
+    }
+    if (plainPrompts.length > 0) {
+      output.push(`
+### Prompts:`);
+      for (let prompt of plainPrompts)
+        output.push(`- ${prompt}`);
+    }
+    let intentsForSession = [
+      ...session.messages.intents,
+      ...session.messages.prompts.map((prompt) => parseUiPromptHandoff(prompt)).filter((handoff) => !!handoff).map((handoff) => ({ intent: handoff.intent, params: handoff.params }))
+    ];
+    if (intentsForSession.length > 0) {
+      output.push(`
+### Intents:`);
+      for (let intent of intentsForSession) {
+        let params = intent.params ? ` (${JSON.stringify(intent.params)})` : "";
+        output.push(`- ${intent.intent}${params}`);
+      }
+    }
+    if (session.messages.notifications.length > 0) {
+      output.push(`
+### Notifications:`);
+      for (let notification of session.messages.notifications)
+        output.push(`- ${notification}`);
+    }
+  }
+  let count = sessions.length;
+  return state.completedUiSessions = [], {
+    content: [{ type: "text", text: output.join(`
+`) }],
+    details: {
+      sessions: count,
+      prompts: allPrompts,
+      intents: [...allIntents, ...parsedHandoffs.map(({ intent, params }) => ({ intent, params }))],
+      handoffs: parsedHandoffs,
+      cleared: !0
+    }
+  };
+}
+function executeStatus(state) {
+  let servers = [];
+  for (let name of Object.keys(state.config.mcpServers)) {
+    let connection = state.manager.getConnection(name), metadata = state.toolMetadata.get(name), toolCount = metadata?.length ?? 0, failedAgo = getFailureAgeSeconds(state, name), status = "not connected";
+    connection?.status === "connected" ? status = "connected" : connection?.status === "needs-auth" ? status = "needs-auth" : failedAgo !== null ? status = "failed" : metadata !== void 0 && (status = "cached"), servers.push({ name, status, toolCount, failedAgo });
+  }
+  let totalTools = servers.reduce((sum, s) => sum + s.toolCount, 0), connectedCount = servers.filter((s) => s.status === "connected").length, text = `MCP: ${connectedCount}/${servers.length} servers, ${totalTools} tools
+
+`;
+  for (let server of servers) {
+    if (server.status === "connected") {
+      text += `\u2713 ${server.name} (${server.toolCount} tools)
+`;
+      continue;
+    }
+    if (server.status === "needs-auth") {
+      text += `\u26A0 ${server.name} (needs auth)
+`;
+      continue;
+    }
+    if (server.status === "cached") {
+      text += `\u25CB ${server.name} (${server.toolCount} tools, cached)
+`;
+      continue;
+    }
+    if (server.status === "failed") {
+      text += `\u2717 ${server.name} (failed ${server.failedAgo ?? 0}s ago)
+`;
+      continue;
+    }
+    text += `\u25CB ${server.name} (not connected)
+`;
+  }
+  return servers.length > 0 && (text += `
+mcp({ server: "name" }) to list tools, mcp({ search: "..." }) to search`), {
+    content: [{ type: "text", text: text.trim() }],
+    details: { mode: "status", servers, totalTools, connectedCount }
+  };
+}
+async function executeAuthStart(state, serverName) {
+  let definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return {
+      content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "auth-start", error: "not_found", server: serverName }
+    };
+  if (!definition.url || !supportsOAuth(definition))
+    return {
+      content: [{ type: "text", text: `Server "${serverName}" is not configured for OAuth over HTTP.` }],
+      details: { mode: "auth-start", error: "oauth_not_supported", server: serverName }
+    };
+  try {
+    let { authorizationUrl } = await startAuth(serverName, definition.url, definition);
+    return authorizationUrl ? {
+      content: [{ type: "text", text: formatManualAuthInstructions(serverName, authorizationUrl) }],
+      details: { mode: "auth-start", server: serverName, authorizationUrl }
+    } : {
+      content: [{ type: "text", text: `OAuth authentication successful for "${serverName}".` }],
+      details: { mode: "auth-start", server: serverName, authenticated: !0 }
+    };
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Failed to start OAuth for "${serverName}": ${message}` }],
+      details: { mode: "auth-start", error: "auth_start_failed", server: serverName, message }
+    };
+  }
+}
+async function executeAuthComplete(state, serverName, input) {
+  if (!state.config.mcpServers[serverName])
+    return {
+      content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "auth-complete", error: "not_found", server: serverName }
+    };
+  try {
+    let status = await completeAuthFromInput(serverName, input);
+    return status !== "authenticated" ? {
+      content: [{ type: "text", text: `OAuth authentication did not complete for "${serverName}".` }],
+      details: { mode: "auth-complete", error: "not_authenticated", server: serverName, status }
+    } : (await state.manager.close(serverName), state.failureTracker.delete(serverName), updateStatusBar(state), {
+      content: [{ type: "text", text: `OAuth authentication successful for "${serverName}". Run mcp({ connect: "${serverName}" }) to connect with the new token.` }],
+      details: { mode: "auth-complete", server: serverName, authenticated: !0 }
+    });
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Failed to complete OAuth for "${serverName}": ${message}` }],
+      details: { mode: "auth-complete", error: "auth_complete_failed", server: serverName, message }
+    };
+  }
+}
+function executeDescribe(state, toolName) {
+  let serverName, toolMeta;
+  for (let [server, metadata] of state.toolMetadata.entries()) {
+    let found = findToolByName(metadata, toolName);
+    if (found) {
+      serverName = server, toolMeta = found;
+      break;
+    }
+  }
+  if (!serverName || !toolMeta)
+    return {
+      content: [{ type: "text", text: `Tool "${toolName}" not found. Use mcp({ search: "..." }) to search.` }],
+      details: { mode: "describe", error: "tool_not_found", requestedTool: toolName }
+    };
+  let text = `${toolMeta.name}
+`;
+  return text += `Server: ${serverName}
+`, toolMeta.resourceUri && (text += `Type: Resource (reads from ${toolMeta.resourceUri})
+`), text += `
+${toolMeta.description || "(no description)"}
+`, toolMeta.inputSchema && !toolMeta.resourceUri ? text += `
+Parameters:
+${formatSchema(toolMeta.inputSchema)}` : toolMeta.resourceUri ? text += `
+No parameters required (resource tool).` : text += `
+No parameters defined.`, {
+    content: [{ type: "text", text: text.trim() }],
+    details: { mode: "describe", tool: toolMeta, server: serverName }
+  };
+}
+function executeSearch(state, query, regex, server, includeSchemas) {
+  let showSchemas = includeSchemas !== !1, matches = [], pattern;
+  try {
+    if (regex) {
+      if (query.length > MAX_REGEX_SEARCH_QUERY_LENGTH)
+        return {
+          content: [{ type: "text", text: `Regex query is too long; maximum length is ${MAX_REGEX_SEARCH_QUERY_LENGTH} characters.` }],
+          details: { mode: "search", error: "query_too_long", query, maxLength: MAX_REGEX_SEARCH_QUERY_LENGTH }
+        };
+      pattern = new RegExp(query, "i");
+      let safety;
+      try {
+        safety = checkSync(query, "i", REGEX_SAFETY_CHECK_PARAMS);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: "Regex query rejected because safety analysis failed." }],
+          details: { mode: "search", error: "unsafe_pattern", query, reason: message }
+        };
+      }
+      if (safety.status !== "safe")
+        return {
+          content: [{ type: "text", text: `Regex query rejected as unsafe (${safety.status}).` }],
+          details: { mode: "search", error: "unsafe_pattern", query, safetyStatus: safety.status }
+        };
+    } else {
+      let terms = query.trim().split(/\s+/).filter((t) => t.length > 0);
+      if (terms.length === 0)
+        return {
+          content: [{ type: "text", text: "Search query cannot be empty" }],
+          details: { mode: "search", error: "empty_query" }
+        };
+      let escaped = terms.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+      pattern = new RegExp(escaped.join("|"), "i");
+    }
+  } catch {
+    return {
+      content: [{ type: "text", text: `Invalid regex: ${query}` }],
+      details: { mode: "search", error: "invalid_pattern", query }
+    };
+  }
+  for (let [serverName, metadata] of state.toolMetadata.entries())
+    if (!(server && serverName !== server))
+      for (let tool of metadata)
+        (pattern.test(tool.name) || pattern.test(tool.description)) && matches.push({
+          server: serverName,
+          tool
+        });
+  let totalCount = matches.length;
+  if (totalCount === 0)
+    return {
+      content: [{ type: "text", text: server ? `No tools matching "${query}" in "${server}"` : `No tools matching "${query}"` }],
+      details: { mode: "search", matches: [], count: 0, query }
+    };
+  let text = `Found ${totalCount} tool${totalCount === 1 ? "" : "s"} matching "${query}":
+
+`;
+  for (let match of matches)
+    showSchemas ? (text += `${match.tool.name}
+`, text += `  ${match.tool.description || "(no description)"}
+`, match.tool.inputSchema && !match.tool.resourceUri ? text += `
+  Parameters:
+${formatSchema(match.tool.inputSchema, "    ")}
+` : match.tool.resourceUri && (text += `  No parameters (resource tool).
+`), text += `
+`) : (text += `- ${match.tool.name}`, match.tool.description && (text += ` - ${truncateAtWord(match.tool.description, 50)}`), text += `
+`);
+  return {
+    content: [{ type: "text", text: text.trim() }],
+    details: {
+      mode: "search",
+      matches: matches.map((m) => ({ server: m.server, tool: m.tool.name })),
+      count: totalCount,
+      query
+    }
+  };
+}
+function executeList(state, server) {
+  if (!state.config.mcpServers[server])
+    return {
+      content: [{ type: "text", text: `Server "${server}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "list", server, tools: [], count: 0, error: "not_found" }
+    };
+  let metadata = state.toolMetadata.get(server), toolNames = metadata?.map((m) => m.name) ?? [], connection = state.manager.getConnection(server);
+  if (toolNames.length === 0)
+    return connection?.status === "connected" ? {
+      content: [{ type: "text", text: `Server "${server}" has no tools.` }],
+      details: { mode: "list", server, tools: [], count: 0 }
+    } : metadata !== void 0 ? {
+      content: [{ type: "text", text: `Server "${server}" has no cached tools (not connected).` }],
+      details: { mode: "list", server, tools: [], count: 0, cached: !0 }
+    } : {
+      content: [{ type: "text", text: `Server "${server}" is configured but not connected. Use mcp({ connect: "${server}" }) or /mcp reconnect ${server} to retry.` }],
+      details: { mode: "list", server, tools: [], count: 0, error: "not_connected" }
+    };
+  let cachedNote = connection?.status === "connected" ? "" : " (not connected, cached)", text = `${server} (${toolNames.length} tools${cachedNote}):
+
+`, descMap = /* @__PURE__ */ new Map();
+  if (metadata)
+    for (let m of metadata)
+      descMap.set(m.name, m.description);
+  for (let tool of toolNames) {
+    let desc = descMap.get(tool) ?? "", truncated = truncateAtWord(desc, 50);
+    text += `- ${tool}`, truncated && (text += ` - ${truncated}`), text += `
+`;
+  }
+  return {
+    content: [{ type: "text", text: text.trim() }],
+    details: { mode: "list", server, tools: toolNames, count: toolNames.length }
+  };
+}
+async function executeConnect(state, serverName, signal) {
+  throwIfAborted(signal);
+  let definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return {
+      content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "connect", error: "not_found", server: serverName }
+    };
+  try {
+    state.ui && state.ui.setStatus("mcp", `MCP: connecting to ${serverName}...`);
+    let connection = await state.manager.connect(serverName, definition, signal);
+    if (connection.status === "needs-auth") {
+      let autoAuth = await attemptAutoAuth(state, serverName);
+      if (autoAuth.status === "failed")
+        return {
+          content: [{ type: "text", text: autoAuth.message }],
+          details: { mode: "connect", error: "auth_required", server: serverName, message: autoAuth.message }
+        };
+      if (autoAuth.status === "success" && (await state.manager.close(serverName), connection = await state.manager.connect(serverName, definition, signal)), connection.status === "needs-auth") {
+        let message = getAuthRequiredMessage(state, serverName);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { mode: "connect", error: "auth_required", server: serverName, message }
+        };
+      }
+    }
+    let prefix = state.config.settings?.toolPrefix ?? "server", { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, serverName, prefix);
+    return state.toolMetadata.set(serverName, metadata), updateMetadataCache(state, serverName), state.failureTracker.delete(serverName), updateStatusBar(state), executeList(state, serverName);
+  } catch (error) {
+    signal?.aborted || state.failureTracker.set(serverName, Date.now()), updateStatusBar(state);
+    let message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [{ type: "text", text: `Failed to connect to "${serverName}": ${message}` }],
+      details: { mode: "connect", error: signal?.aborted ? "aborted" : "connect_failed", server: serverName, message }
+    };
+  }
+}
+async function executeCall(state, toolName, args, serverOverride, getPiTools, signal) {
+  throwIfAborted(signal);
+  let serverName = serverOverride, toolMeta, autoAuthAttempted = !1, prefixMode = state.config.settings?.toolPrefix ?? "server";
+  if (serverName && !state.config.mcpServers[serverName])
+    return {
+      content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({}) to see available servers.` }],
+      details: { mode: "call", error: "server_not_found", server: serverName }
+    };
+  if (serverName)
+    toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
+  else
+    for (let [server, metadata] of state.toolMetadata.entries()) {
+      let found = findToolByName(metadata, toolName);
+      if (found) {
+        serverName = server, toolMeta = found;
+        break;
+      }
+    }
+  if (serverName && !toolMeta)
+    if (await lazyConnect(state, serverName, signal))
+      toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
+    else {
+      if (state.manager.getConnection(serverName)?.status === "needs-auth") {
+        if (!autoAuthAttempted) {
+          autoAuthAttempted = !0;
+          let autoAuth = await attemptAutoAuth(state, serverName);
+          if (autoAuth.status === "failed")
+            return {
+              content: [{ type: "text", text: autoAuth.message }],
+              details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message }
+            };
+          if (autoAuth.status === "success" && (await state.manager.close(serverName), state.failureTracker.delete(serverName), await lazyConnect(state, serverName, signal) && (toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName), !toolMeta)))
+            return {
+              content: [{ type: "text", text: `Tool "${toolName}" not found on "${serverName}" after reconnect.` }],
+              details: { mode: "call", error: "tool_not_found_after_reconnect", requestedTool: toolName }
+            };
+        }
+        if (!toolMeta && state.manager.getConnection(serverName)?.status === "needs-auth") {
+          let message = getAuthRequiredMessage(state, serverName);
+          return {
+            content: [{ type: "text", text: message }],
+            details: { mode: "call", error: "auth_required", server: serverName, message }
+          };
+        }
+      }
+      if (!toolMeta) {
+        let failedAgo = getFailureAgeSeconds(state, serverName);
+        if (failedAgo !== null)
+          return {
+            content: [{ type: "text", text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
+            details: { mode: "call", error: "server_backoff", server: serverName }
+          };
+      }
+    }
+  let prefixMatchedServer;
+  if (!serverName && !toolMeta && prefixMode !== "none") {
+    let candidates = Object.keys(state.config.mcpServers).map((name) => ({ name, prefix: getServerPrefix(name, prefixMode) })).filter((c) => c.prefix && toolName.startsWith(c.prefix + "_")).sort((a, b) => b.prefix.length - a.prefix.length);
+    for (let { name: configuredServer } of candidates) {
+      let existingConnection = state.manager.getConnection(configuredServer);
+      if (getFailureAgeSeconds(state, configuredServer) !== null && existingConnection?.status !== "needs-auth")
+        continue;
+      let connected = await lazyConnect(state, configuredServer, signal);
+      if (!connected && state.manager.getConnection(configuredServer)?.status === "needs-auth" && !autoAuthAttempted) {
+        autoAuthAttempted = !0;
+        let autoAuth = await attemptAutoAuth(state, configuredServer);
+        if (autoAuth.status === "failed")
+          return {
+            content: [{ type: "text", text: autoAuth.message }],
+            details: { mode: "call", error: "auth_required", server: configuredServer, message: autoAuth.message }
+          };
+        autoAuth.status === "success" && (await state.manager.close(configuredServer), state.failureTracker.delete(configuredServer), connected = await lazyConnect(state, configuredServer, signal));
+      }
+      if (connected && (prefixMatchedServer || (prefixMatchedServer = configuredServer), toolMeta = findToolByName(state.toolMetadata.get(configuredServer), toolName), toolMeta)) {
+        serverName = configuredServer;
+        break;
+      }
+    }
+  }
+  if (!serverName || !toolMeta) {
+    if (serverOverride ? void 0 : getPiTools?.().find((tool) => tool.name === toolName && tool.name !== "mcp"))
+      return {
+        content: [{ type: "text", text: `"${toolName}" is a native Pi tool. Call ${toolName} directly instead of using mcp({ tool: "${toolName}" }).` }],
+        details: { mode: "call", error: "native_tool", requestedTool: toolName }
+      };
+    let hintServer = serverName ?? prefixMatchedServer, available = hintServer ? getToolNames(state, hintServer) : [], msg = `Tool "${toolName}" not found.`;
+    return available.length > 0 ? msg += ` Server "${hintServer}" has: ${available.join(", ")}` : msg += ' Use mcp({ search: "..." }) to search.', {
+      content: [{ type: "text", text: msg }],
+      details: { mode: "call", error: "tool_not_found", requestedTool: toolName, hintServer }
+    };
+  }
+  let connection = state.manager.getConnection(serverName);
+  if (connection?.status === "needs-auth") {
+    if (!autoAuthAttempted) {
+      autoAuthAttempted = !0;
+      let autoAuth = await attemptAutoAuth(state, serverName);
+      if (autoAuth.status === "failed")
+        return {
+          content: [{ type: "text", text: autoAuth.message }],
+          details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message }
+        };
+      autoAuth.status === "success" && (await state.manager.close(serverName), state.failureTracker.delete(serverName), connection = state.manager.getConnection(serverName));
+    }
+    if (connection?.status === "needs-auth") {
+      let message = getAuthRequiredMessage(state, serverName);
+      return {
+        content: [{ type: "text", text: message }],
+        details: { mode: "call", error: "auth_required", server: serverName, message }
+      };
+    }
+  }
+  if (!connection || connection.status !== "connected") {
+    let failedAgo = getFailureAgeSeconds(state, serverName);
+    if (failedAgo !== null)
+      return {
+        content: [{ type: "text", text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
+        details: { mode: "call", error: "server_backoff", server: serverName }
+      };
+    let definition = state.config.mcpServers[serverName];
+    if (!definition)
+      return {
+        content: [{ type: "text", text: `Server "${serverName}" not connected` }],
+        details: { mode: "call", error: "server_not_connected", server: serverName }
+      };
+    try {
+      if (state.ui && state.ui.setStatus("mcp", `MCP: connecting to ${serverName}...`), connection = await state.manager.connect(serverName, definition, signal), connection.status === "needs-auth") {
+        if (!autoAuthAttempted) {
+          autoAuthAttempted = !0;
+          let autoAuth = await attemptAutoAuth(state, serverName);
+          if (autoAuth.status === "failed")
+            return {
+              content: [{ type: "text", text: autoAuth.message }],
+              details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message }
+            };
+          autoAuth.status === "success" && (await state.manager.close(serverName), connection = await state.manager.connect(serverName, definition, signal));
+        }
+        if (connection.status === "needs-auth") {
+          let message = getAuthRequiredMessage(state, serverName);
+          return {
+            content: [{ type: "text", text: message }],
+            details: { mode: "call", error: "auth_required", server: serverName, message }
+          };
+        }
+      }
+      if (state.failureTracker.delete(serverName), updateServerMetadata(state, serverName), updateMetadataCache(state, serverName), updateStatusBar(state), toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName), !toolMeta) {
+        let available = getToolNames(state, serverName), hint = available.length > 0 ? `Available tools on "${serverName}": ${available.join(", ")}` : `Server "${serverName}" has no tools.`;
+        return {
+          content: [{ type: "text", text: `Tool "${toolName}" not found on "${serverName}" after reconnect. ${hint}` }],
+          details: { mode: "call", error: "tool_not_found_after_reconnect", requestedTool: toolName }
+        };
+      }
+    } catch (error) {
+      signal?.aborted || state.failureTracker.set(serverName, Date.now()), updateStatusBar(state);
+      let message = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Failed to connect to "${serverName}": ${message}` }],
+        details: { mode: "call", error: signal?.aborted ? "aborted" : "connect_failed", message }
+      };
+    }
+  }
+  let uiSession = null, requestOptions = state.manager.getRequestOptions?.(serverName, signal) ?? (signal ? { signal } : void 0), outputGuardOptions = resolveMcpOutputGuardOptions(state.config.settings);
+  try {
+    if (state.manager.touch(serverName), state.manager.incrementInFlight(serverName), toolMeta.resourceUri) {
+      let content2 = ((await connection.client.readResource({ uri: toolMeta.resourceUri }, requestOptions)).contents ?? []).map((c) => ({
+        type: "text",
+        text: "text" in c ? c.text : "blob" in c ? `[Binary data: ${c.mimeType ?? "unknown"}]` : JSON.stringify(c)
+      })), guarded2 = await guardMcpOutput(content2.length > 0 ? content2 : [{ type: "text", text: "(empty resource)" }], outputGuardOptions);
+      return {
+        content: guarded2.content,
+        details: { mode: "call", resourceUri: toolMeta.resourceUri, server: serverName, ...guardedMcpDetails(guarded2) }
+      };
+    }
+    uiSession = toolMeta.uiResourceUri ? await maybeStartUiSession(state, {
+      serverName,
+      toolName: toolMeta.originalName,
+      toolArgs: args ?? {},
+      uiResourceUri: toolMeta.uiResourceUri,
+      streamMode: toolMeta.uiStreamMode
+    }) : null;
+    let resultPromise = connection.client.callTool({
+      name: toolMeta.originalName,
+      arguments: args ?? {},
+      _meta: uiSession?.requestMeta
+    }, void 0, requestOptions);
+    if (toolMeta.uiResourceUri) {
+      let result2 = await abortable(resultPromise, signal);
+      if (uiSession?.sendToolResult(result2), result2.isError) {
+        let mcpContent = result2.content ?? [], content3 = transformMcpContent(mcpContent), outputContent3 = content3.length > 0 ? content3 : [{ type: "text", text: "(empty result)" }], schemaText = toolMeta.inputSchema ? `
+
+Expected parameters:
+${formatSchema(toolMeta.inputSchema)}` : "", guarded3 = await guardMcpOutput(outputContent3, { ...outputGuardOptions, prefix: "Error: ", suffix: schemaText, emptyTextFallback: "Tool execution failed", rawMcpResult: result2 });
+        return {
+          content: guarded3.content,
+          details: { mode: "call", error: "tool_error", ...guardedMcpDetails(guarded3) }
+        };
+      }
+      let content2 = resolveMcpResultContent(result2), outputContent2 = content2.length > 0 ? content2 : [{ type: "text", text: "(empty result)" }], uiMessage = uiSession?.reused ? "Updated the open UI." : "\u{1F4FA} Interactive UI is now open in your browser. I'll respond to your prompts and intents as you interact with it.", guarded2 = await guardMcpOutput(outputContent2, { ...outputGuardOptions, suffix: `
+
+${uiMessage}`, rawMcpResult: result2 });
+      return {
+        content: guarded2.content,
+        details: { mode: "call", ...guardedMcpDetails(guarded2), server: serverName, tool: toolMeta.originalName, uiOpen: !0 }
+      };
+    }
+    let result = await abortable(resultPromise, signal);
+    if (result.isError) {
+      let mcpContent = result.content ?? [], content2 = transformMcpContent(mcpContent), outputContent2 = content2.length > 0 ? content2 : [{ type: "text", text: "(empty result)" }], schemaText = toolMeta.inputSchema ? `
+
+Expected parameters:
+${formatSchema(toolMeta.inputSchema)}` : "", guarded2 = await guardMcpOutput(outputContent2, { ...outputGuardOptions, prefix: "Error: ", suffix: schemaText, emptyTextFallback: "Tool execution failed", rawMcpResult: result });
+      return {
+        content: guarded2.content,
+        details: { mode: "call", error: "tool_error", ...guardedMcpDetails(guarded2) }
+      };
+    }
+    let content = resolveMcpResultContent(result), outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }], guarded = await guardMcpOutput(outputContent, { ...outputGuardOptions, rawMcpResult: result });
+    return {
+      content: guarded.content,
+      details: { mode: "call", ...guardedMcpDetails(guarded), server: serverName, tool: toolMeta.originalName }
+    };
+  } catch (error) {
+    if (error instanceof UrlElicitationRequiredError) {
+      let action = await state.manager.handleUrlElicitationRequired(serverName, error), message2 = action === "accept" ? "The original MCP tool did not run. Complete the opened browser interaction, then retry the tool." : `The URL interaction was ${action === "decline" ? "declined" : "cancelled"}.`;
+      return uiSession?.sendToolCancelled(message2), {
+        content: [{ type: "text", text: message2 }],
+        details: { mode: "call", error: "url_elicitation_required", server: serverName, action }
+      };
+    }
+    let message = error instanceof Error ? error.message : String(error);
+    uiSession?.sendToolCancelled(message);
+    let schemaText = toolMeta.inputSchema ? `
+
+Expected parameters:
+${formatSchema(toolMeta.inputSchema)}` : "", guarded = await guardMcpOutput([{ type: "text", text: message }], { ...outputGuardOptions, prefix: "Failed to call tool: ", suffix: schemaText });
+    return {
+      content: guarded.content,
+      details: { mode: "call", error: "call_failed", message: guarded.outputGuard ? "output truncated; see outputGuard.fullOutputPath" : message, ...guardedMcpDetails(guarded) }
+    };
+  } finally {
+    uiSession?.reused && uiSession.close(), state.manager.decrementInFlight(serverName), state.manager.touch(serverName);
+  }
+}
+export {
+  executeAuthComplete,
+  executeAuthStart,
+  executeCall,
+  executeConnect,
+  executeDescribe,
+  executeList,
+  executeSearch,
+  executeStatus,
+  executeUiMessages
+};