@mcpc-tech/core 0.3.9 → 0.3.11

package/plugins/search.cjs

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/search-tool.ts
+var search_tool_exports = {};
+__export(search_tool_exports, {
+  createPlugin: () => createPlugin,
+  createSearchPlugin: () => createSearchPlugin,
+  default: () => search_tool_default
+});
+module.exports = __toCommonJS(search_tool_exports);
+var import_ripgrep_napi = __toESM(require("@mcpc-tech/ripgrep-napi"), 1);
+var import_node_os = require("node:os");
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/search-tool.ts
+var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
+function createSearchPlugin(options = {}) {
+  const maxResults = options.maxResults || 20;
+  const maxOutputSize = options.maxOutputSize || 5e3;
+  const allowedSearchDir = options.allowedDir || (0, import_node_os.tmpdir)();
+  const timeoutMs = options.timeoutMs || 3e4;
+  const global = options.global ?? true;
+  const activeTimeouts = /* @__PURE__ */ new Set();
+  return {
+    name: "plugin-search",
+    version: "1.0.0",
+    configureServer: (server) => {
+      const defaultDescription = `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`;
+      const toolDescription = options.toolDescription || defaultDescription;
+      server.tool(
+        "search-tool-result",
+        toolDescription,
+        jsonSchema({
+          type: "object",
+          properties: {
+            pattern: {
+              type: "string",
+              description: "Text to search for. Can be a plain string or a regular expression. For regexes, don't include delimiters (e.g. use `^foo` not `/^foo/`). If you get a regex parse error, try escaping special chars or using a simpler literal search."
+            },
+            path: {
+              type: "string",
+              description: "File or folder path to limit the search (optional). Must be within the allowed directory."
+            },
+            maxResults: {
+              type: "number",
+              description: "Maximum number of matches to return (optional). Lower this to reduce output size and runtime."
+            }
+          },
+          required: ["pattern"]
+        }),
+        async (args) => {
+          const isBroad = (raw) => {
+            const t = (raw ?? "").trim();
+            if (!t) return true;
+            if (/^[*.\s]{2,}$/.test(t)) return true;
+            if (t === ".*" || t === "." || t === "^.*$") return true;
+            if (/^\^?\.\*\$?$/.test(t)) return true;
+            if (/^\\s?\*+$/.test(t)) return true;
+            return false;
+          };
+          const appendMatchSafely = (current, addition, limit) => {
+            if ((current + addition).length > limit) {
+              return { current, added: false };
+            }
+            return { current: current + addition, added: true };
+          };
+          let timeoutId;
+          try {
+            const requestedPath = args.path || allowedSearchDir;
+            const limit = args.maxResults || maxResults;
+            if (args.path) {
+              const resolvedRequested = (0, import_node_path.resolve)(args.path);
+              const resolvedAllowed = (0, import_node_path.resolve)(allowedSearchDir);
+              const relativePath = (0, import_node_path2.relative)(resolvedAllowed, resolvedRequested);
+              if (relativePath && relativePath.startsWith("..")) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `\u274C Path "${args.path}" not allowed. Must be within: ${allowedSearchDir}`
+                    }
+                  ],
+                  isError: true
+                };
+              }
+            }
+            const searchPath = requestedPath;
+            const rawPattern = args.pattern ?? "";
+            if (isBroad(rawPattern)) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u274C Search pattern too broad: "${rawPattern}"
+Provide a more specific pattern (e.g. include a filename fragment, a keyword, or limit with the "path" parameter). Avoid patterns that only contain wildcards like "*" or ".*".`
+                  }
+                ],
+                isError: true
+              };
+            }
+            const timeoutPromise = new Promise((_, reject) => {
+              timeoutId = setTimeout(() => {
+                reject(new Error(`Search timeout after ${timeoutMs}ms`));
+              }, timeoutMs);
+              activeTimeouts.add(timeoutId);
+            });
+            const searchPromise = new Promise((resolve2, reject) => {
+              try {
+                const result2 = import_ripgrep_napi.default.search(args.pattern, [searchPath]);
+                resolve2(result2);
+              } catch (error) {
+                reject(error);
+              }
+            });
+            const result = await Promise.race([
+              searchPromise,
+              timeoutPromise
+            ]);
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              activeTimeouts.delete(timeoutId);
+            }
+            if (!result.success || !result.matches?.length) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `No matches found for: "${args.pattern}"
+
+Try:
+- **Simpler pattern** or \`*\`
+- Check if files exist in: ${searchPath}
+- Use specific file path`
+                  }
+                ]
+              };
+            }
+            const matches = result.matches.slice(0, limit);
+            let output = `Found ${result.matches.length} matches (showing up to ${matches.length}):
+
+`;
+            let matchesIncluded = 0;
+            for (const match of matches) {
+              const baseMatchText = `**${match.path}:${match.lineNumber}**
+`;
+              const fullMatchText = `${baseMatchText}\`\`\`
+${match.line}
+\`\`\`
+
+`;
+              const res = appendMatchSafely(
+                output,
+                fullMatchText,
+                maxOutputSize
+              );
+              if (!res.added) {
+                if (matchesIncluded === 0) {
+                  const remainingSpace = maxOutputSize - output.length - 100;
+                  if (remainingSpace > 50) {
+                    const truncatedLine = match.line.slice(0, remainingSpace);
+                    output += `${baseMatchText}\`\`\`
+${truncatedLine}...
+\`\`\`
+
+`;
+                    output += `\u26A0\uFE0F Content truncated
+`;
+                    matchesIncluded++;
+                  } else {
+                    output += `\u26A0\uFE0F Content too large, use specific file path
+`;
+                  }
+                }
+                break;
+              }
+              output = res.current;
+              matchesIncluded++;
+            }
+            if (matchesIncluded < matches.length) {
+              output += `
+\u26A0\uFE0F Showing ${matchesIncluded}/${matches.length} matches (size limit)
+`;
+              output += `
+For more results:
+`;
+              output += `- Use specific pattern: "${args.pattern} keyword"
+`;
+              output += `- Search specific file: {"pattern": "${args.pattern}", "path": "/file.txt"}
+`;
+              output += `- Use fewer results: {"maxResults": 5}`;
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: output
+                }
+              ]
+            };
+          } catch (error) {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              activeTimeouts.delete(timeoutId);
+            }
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const isTimeout = errorMsg.includes("timeout");
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Search error: ${errorMsg}
+
+${isTimeout ? `Timeout after ${timeoutMs}ms. Try simpler pattern or smaller directory.` : `Check pattern syntax or directory exists.`}`
+                }
+              ]
+            };
+          }
+        },
+        { internal: !global }
+      );
+    },
+    dispose: () => {
+      for (const timeoutId of activeTimeouts) {
+        clearTimeout(timeoutId);
+      }
+      activeTimeouts.clear();
+    }
+  };
+}
+var defaultSearchPlugin = createSearchPlugin({
+  global: true,
+  maxResults: 20,
+  maxOutputSize: 5e3,
+  caseSensitive: false,
+  timeoutMs: 3e4
+});
+var createPlugin = createSearchPlugin;
+var search_tool_default = defaultSearchPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlugin,
+  createSearchPlugin
+});

package/plugins/search.mjs

@@ -40,10 +40,12 @@ function createSearchPlugin(options = {}) {
     name: "plugin-search",
     version: "1.0.0",
     configureServer: (server) => {
+      const defaultDescription = `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`;
+      const toolDescription = options.toolDescription || defaultDescription;
       server.tool(
         "search-tool-result",
-        `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
-Only search within the allowed directory: ${allowedSearchDir}`,
+        toolDescription,
         jsonSchema({
           type: "object",
           properties: {

package/plugins.cjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// __mcpc__core_latest/node_modules/@mcpc/core/plugins.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  createLargeResultPlugin: () => createLargeResultPlugin,
+  createSearchPlugin: () => createSearchPlugin,
+  defaultLargeResultPlugin: () => large_result_default,
+  defaultSearchPlugin: () => search_tool_default
+});
+module.exports = __toCommonJS(plugins_exports);
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/search-tool.js
+var import_ripgrep_napi = __toESM(require("@mcpc-tech/ripgrep-napi"), 1);
+var import_node_os = require("node:os");
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/utils/schema.js
+var schemaSymbol = Symbol.for("mcpc.schema");
+var vercelSchemaSymbol = Symbol.for("vercel.ai.schema");
+var validatorSymbol = Symbol.for("mcpc.validator");
+function jsonSchema(schema, options = {}) {
+  if (isWrappedSchema(schema)) {
+    return schema;
+  }
+  return {
+    [schemaSymbol]: true,
+    [validatorSymbol]: true,
+    _type: void 0,
+    jsonSchema: schema,
+    validate: options.validate
+  };
+}
+function isWrappedSchema(value) {
+  return typeof value === "object" && value !== null && (schemaSymbol in value && value[schemaSymbol] === true || vercelSchemaSymbol in value && value[vercelSchemaSymbol] === true);
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/search-tool.js
+var import_node_path = require("node:path");
+var import_node_path2 = require("node:path");
+function createSearchPlugin(options = {}) {
+  const maxResults = options.maxResults || 20;
+  const maxOutputSize = options.maxOutputSize || 5e3;
+  const allowedSearchDir = options.allowedDir || (0, import_node_os.tmpdir)();
+  const timeoutMs = options.timeoutMs || 3e4;
+  const global = options.global ?? true;
+  const activeTimeouts = /* @__PURE__ */ new Set();
+  return {
+    name: "plugin-search",
+    version: "1.0.0",
+    configureServer: (server) => {
+      const defaultDescription = `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
+Only search within the allowed directory: ${allowedSearchDir}`;
+      const toolDescription = options.toolDescription || defaultDescription;
+      server.tool("search-tool-result", toolDescription, jsonSchema({
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "Text to search for. Can be a plain string or a regular expression. For regexes, don't include delimiters (e.g. use `^foo` not `/^foo/`). If you get a regex parse error, try escaping special chars or using a simpler literal search."
+          },
+          path: {
+            type: "string",
+            description: "File or folder path to limit the search (optional). Must be within the allowed directory."
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of matches to return (optional). Lower this to reduce output size and runtime."
+          }
+        },
+        required: [
+          "pattern"
+        ]
+      }), async (args) => {
+        const isBroad = (raw) => {
+          const t = (raw ?? "").trim();
+          if (!t) return true;
+          if (/^[*.\s]{2,}$/.test(t)) return true;
+          if (t === ".*" || t === "." || t === "^.*$") return true;
+          if (/^\^?\.\*\$?$/.test(t)) return true;
+          if (/^\\s?\*+$/.test(t)) return true;
+          return false;
+        };
+        const appendMatchSafely = (current, addition, limit) => {
+          if ((current + addition).length > limit) {
+            return {
+              current,
+              added: false
+            };
+          }
+          return {
+            current: current + addition,
+            added: true
+          };
+        };
+        let timeoutId;
+        try {
+          const requestedPath = args.path || allowedSearchDir;
+          const limit = args.maxResults || maxResults;
+          if (args.path) {
+            const resolvedRequested = (0, import_node_path.resolve)(args.path);
+            const resolvedAllowed = (0, import_node_path.resolve)(allowedSearchDir);
+            const relativePath = (0, import_node_path2.relative)(resolvedAllowed, resolvedRequested);
+            if (relativePath && relativePath.startsWith("..")) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u274C Path "${args.path}" not allowed. Must be within: ${allowedSearchDir}`
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
+          const searchPath = requestedPath;
+          const rawPattern = args.pattern ?? "";
+          if (isBroad(rawPattern)) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `\u274C Search pattern too broad: "${rawPattern}"
+Provide a more specific pattern (e.g. include a filename fragment, a keyword, or limit with the "path" parameter). Avoid patterns that only contain wildcards like "*" or ".*".`
+                }
+              ],
+              isError: true
+            };
+          }
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+              reject(new Error(`Search timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            activeTimeouts.add(timeoutId);
+          });
+          const searchPromise = new Promise((resolve2, reject) => {
+            try {
+              const result2 = import_ripgrep_napi.default.search(args.pattern, [
+                searchPath
+              ]);
+              resolve2(result2);
+            } catch (error) {
+              reject(error);
+            }
+          });
+          const result = await Promise.race([
+            searchPromise,
+            timeoutPromise
+          ]);
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+            activeTimeouts.delete(timeoutId);
+          }
+          if (!result.success || !result.matches?.length) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No matches found for: "${args.pattern}"
+
+Try:
+- **Simpler pattern** or \`*\`
+- Check if files exist in: ${searchPath}
+- Use specific file path`
+                }
+              ]
+            };
+          }
+          const matches = result.matches.slice(0, limit);
+          let output = `Found ${result.matches.length} matches (showing up to ${matches.length}):
+
+`;
+          let matchesIncluded = 0;
+          for (const match of matches) {
+            const baseMatchText = `**${match.path}:${match.lineNumber}**
+`;
+            const fullMatchText = `${baseMatchText}\`\`\`
+${match.line}
+\`\`\`
+
+`;
+            const res = appendMatchSafely(output, fullMatchText, maxOutputSize);
+            if (!res.added) {
+              if (matchesIncluded === 0) {
+                const remainingSpace = maxOutputSize - output.length - 100;
+                if (remainingSpace > 50) {
+                  const truncatedLine = match.line.slice(0, remainingSpace);
+                  output += `${baseMatchText}\`\`\`
+${truncatedLine}...
+\`\`\`
+
+`;
+                  output += `\u26A0\uFE0F Content truncated
+`;
+                  matchesIncluded++;
+                } else {
+                  output += `\u26A0\uFE0F Content too large, use specific file path
+`;
+                }
+              }
+              break;
+            }
+            output = res.current;
+            matchesIncluded++;
+          }
+          if (matchesIncluded < matches.length) {
+            output += `
+\u26A0\uFE0F Showing ${matchesIncluded}/${matches.length} matches (size limit)
+`;
+            output += `
+For more results:
+`;
+            output += `- Use specific pattern: "${args.pattern} keyword"
+`;
+            output += `- Search specific file: {"pattern": "${args.pattern}", "path": "/file.txt"}
+`;
+            output += `- Use fewer results: {"maxResults": 5}`;
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: output
+              }
+            ]
+          };
+        } catch (error) {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+            activeTimeouts.delete(timeoutId);
+          }
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          const isTimeout = errorMsg.includes("timeout");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Search error: ${errorMsg}
+
+${isTimeout ? `Timeout after ${timeoutMs}ms. Try simpler pattern or smaller directory.` : `Check pattern syntax or directory exists.`}`
+              }
+            ]
+          };
+        }
+      }, {
+        internal: !global
+      });
+    },
+    dispose: () => {
+      for (const timeoutId of activeTimeouts) {
+        clearTimeout(timeoutId);
+      }
+      activeTimeouts.clear();
+    }
+  };
+}
+var defaultSearchPlugin = createSearchPlugin({
+  global: true,
+  maxResults: 20,
+  maxOutputSize: 5e3,
+  caseSensitive: false,
+  timeoutMs: 3e4
+});
+var search_tool_default = defaultSearchPlugin;
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/large-result.js
+var import_promises = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+var import_node_os2 = require("node:os");
+function createLargeResultPlugin(options = {}) {
+  const maxSize = options.maxSize || 8e3;
+  const previewSize = options.previewSize || 4e3;
+  let tempDir = options.tempDir || null;
+  const configuredServers = /* @__PURE__ */ new Map();
+  const defaultSearchDescription = `Search within large tool result files that were saved due to size limits. Use when: a tool result was saved to file because it exceeded the context limit. Do NOT use this tool before calling the actual tool first. Provide specific keywords or patterns related to the content you're looking for.`;
+  const searchConfig = {
+    maxResults: options.search?.maxResults || 15,
+    maxOutputSize: options.search?.maxOutputSize || 4e3,
+    toolDescription: options.search?.toolDescription || defaultSearchDescription,
+    global: true
+  };
+  return {
+    name: "plugin-large-result-handler",
+    version: "1.0.0",
+    dependencies: [],
+    configureServer: async (server) => {
+      if (!configuredServers.has(server)) {
+        const searchPlugin = createSearchPlugin(searchConfig);
+        await server.addPlugin(searchPlugin);
+        configuredServers.set(server, true);
+      }
+    },
+    transformTool: (tool, context) => {
+      const originalExecute = tool.execute;
+      tool.execute = async (args) => {
+        try {
+          const result = await originalExecute(args);
+          const resultText = JSON.stringify(result);
+          if (resultText.length <= maxSize) {
+            return result;
+          }
+          if (!tempDir) {
+            tempDir = await (0, import_promises.mkdtemp)((0, import_node_path3.join)((0, import_node_os2.tmpdir)(), "mcpc-results-"));
+          }
+          const safeToolName = encodeURIComponent(context.toolName ?? "tool");
+          const fileName = `${safeToolName}-${Date.now()}.txt`;
+          const filePath = (0, import_node_path3.join)(tempDir, fileName);
+          await (0, import_promises.writeFile)(filePath, resultText);
+          const preview = resultText.slice(0, previewSize);
+          const sizeKB = (resultText.length / 1024).toFixed(1);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `**Result too large (${resultText.length} chars), saved to file**
+
+\u{1F4C1} **File:** ${filePath}
+\u{1F4CA} **Size:** ${sizeKB} KB
+
+**Preview (${previewSize} chars):**
+\`\`\`
+${preview}
+\`\`\`
+
+**To read/understand the full content:**
+- Use the \`search-tool-result\` tool with pattern: \`search-tool-result {"pattern": "your-search-term"}\`
+- Search supports regex patterns for advanced queries`
+              }
+            ]
+          };
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          console.error(`Large result plugin error for ${context.toolName}: ${errorMsg}`);
+          throw error;
+        }
+      };
+      return tool;
+    },
+    dispose: () => {
+      configuredServers.clear();
+      tempDir = null;
+    }
+  };
+}
+var defaultLargeResultPlugin = createLargeResultPlugin({
+  maxSize: 8e3,
+  previewSize: 4e3
+});
+var large_result_default = defaultLargeResultPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLargeResultPlugin,
+  createSearchPlugin,
+  defaultLargeResultPlugin,
+  defaultSearchPlugin
+});