mcp-use 2.0.0-beta.35 → 2.0.0-beta.36

package/dist/mcp-proxy-JK7IC5CR.js

@@ -1,281 +0,0 @@
-// src/mcp-proxy.ts
-var PROXY_CLIENT_INSTALL_HINT = [
-  "[mcp-use] server.proxy() requires the optional @mcp-use/client package.",
-  "Install it in your project:",
-  "",
-  "  npm install @mcp-use/client"
-].join("\n");
-function passthroughJsonSchema(schema) {
-  return {
-    "~standard": {
-      version: 1,
-      vendor: "mcp-use-proxy",
-      validate(value) {
-        return { value };
-      },
-      jsonSchema: {
-        input: () => schema,
-        output: () => schema
-      }
-    }
-  };
-}
-function promptArgsToJsonSchema(args) {
-  const properties = /* @__PURE__ */ Object.create(null);
-  const required = [];
-  for (const arg of args ?? []) {
-    properties[arg.name] = {
-      type: "string",
-      ...arg.description !== void 0 && { description: arg.description }
-    };
-    if (arg.required === true) required.push(arg.name);
-  }
-  return {
-    type: "object",
-    properties,
-    ...required.length > 0 && { required }
-  };
-}
-function prefixedName(namespace, name) {
-  return `${namespace}_${name}`;
-}
-function proxiedResourceUri(namespace, uri) {
-  return `mcp-use-proxy:///${encodeURIComponent(namespace)}/${encodeURIComponent(uri)}`;
-}
-function isConnection(value) {
-  if (value === null || typeof value !== "object") return false;
-  const candidate = value;
-  return typeof candidate.listTools === "function" && typeof candidate.callTool === "function" && typeof candidate.readResource === "function" && typeof candidate.listPrompts === "function" && typeof candidate.getPrompt === "function";
-}
-function isClientPackageMissing(error) {
-  if (!(error instanceof Error)) return false;
-  const code = error.code;
-  return (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("@mcp-use/client");
-}
-function proxyDiagnostic(message, error) {
-  if (error === void 0) {
-    console.error(`[mcp-use] ${message}`);
-    return;
-  }
-  const detail = error instanceof Error ? error.message : String(error);
-  console.error(`[mcp-use] ${message}: ${detail}`);
-}
-function proxyClientInstallError(error) {
-  return isClientPackageMissing(error) ? new Error(PROXY_CLIENT_INSTALL_HINT, { cause: error }) : void 0;
-}
-async function loadProxyClient(importer = () => import("@mcp-use/client")) {
-  try {
-    return await importer();
-  } catch (error) {
-    const installError = proxyClientInstallError(error);
-    if (installError !== void 0) throw installError;
-    throw error;
-  }
-}
-function supports(connection, capability) {
-  return connection.supports?.(capability) !== false;
-}
-async function introspect(namespace, connection) {
-  let tools = [];
-  if (supports(connection, "tools")) {
-    try {
-      tools = await connection.listTools();
-    } catch (error) {
-      proxyDiagnostic(
-        `Failed to introspect tools from upstream MCP server "${namespace}"`,
-        error
-      );
-    }
-  }
-  let resources = [];
-  if (supports(connection, "resources")) {
-    try {
-      if (connection.listAllResources !== void 0) {
-        resources = (await connection.listAllResources()).resources;
-      } else if (connection.listResources !== void 0) {
-        resources = (await connection.listResources()).resources;
-      }
-    } catch (error) {
-      proxyDiagnostic(
-        `Failed to introspect resources from upstream MCP server "${namespace}"`,
-        error
-      );
-    }
-  }
-  let prompts = [];
-  if (supports(connection, "prompts")) {
-    try {
-      prompts = (await connection.listPrompts()).prompts;
-    } catch (error) {
-      proxyDiagnostic(
-        `Failed to introspect prompts from upstream MCP server "${namespace}"`,
-        error
-      );
-    }
-  }
-  return { namespace, connection, tools, resources, prompts };
-}
-function mountPlan(host, plan) {
-  for (const tool of plan.tools) {
-    const name = prefixedName(plan.namespace, tool.name);
-    if (host.hasTool(name)) {
-      proxyDiagnostic(
-        `Skipping proxied tool "${name}" from upstream "${plan.namespace}" because that name is already registered`
-      );
-      continue;
-    }
-    const definition = {
-      name,
-      ...tool.title !== void 0 && { title: tool.title },
-      ...tool.description !== void 0 && { description: tool.description },
-      ...tool.annotations !== void 0 && { annotations: tool.annotations },
-      ...tool.inputSchema !== void 0 && {
-        inputSchema: passthroughJsonSchema(tool.inputSchema)
-      },
-      ...tool.outputSchema !== void 0 && {
-        outputSchema: passthroughJsonSchema(tool.outputSchema)
-      }
-    };
-    const upstreamName = tool.name;
-    const callback = async (params, ctx) => {
-      let progressForwarding = Promise.resolve();
-      try {
-        return await plan.connection.callTool(upstreamName, params, {
-          signal: ctx.signal,
-          onprogress: (progress) => {
-            progressForwarding = progressForwarding.then(async () => {
-              try {
-                await ctx.reportProgress(
-                  progress.progress,
-                  progress.total,
-                  progress.message
-                );
-              } catch (error) {
-                proxyDiagnostic(
-                  `Failed to forward progress for proxied tool "${definition.name}"`,
-                  error
-                );
-              }
-            });
-          }
-        });
-      } finally {
-        await progressForwarding;
-      }
-    };
-    host.registerTool(definition, callback);
-  }
-  for (const resource of plan.resources) {
-    const name = prefixedName(plan.namespace, resource.name);
-    if (host.hasResource(name)) {
-      proxyDiagnostic(
-        `Skipping proxied resource "${name}" from upstream "${plan.namespace}" because that name is already registered`
-      );
-      continue;
-    }
-    const upstreamUri = resource.uri;
-    host.registerResource(
-      {
-        name,
-        uri: proxiedResourceUri(plan.namespace, upstreamUri),
-        ...resource.title !== void 0 && { title: resource.title },
-        ...resource.description !== void 0 && {
-          description: resource.description
-        },
-        ...resource.mimeType !== void 0 && {
-          mimeType: resource.mimeType
-        }
-      },
-      async (_uri, ctx) => plan.connection.readResource(upstreamUri, { signal: ctx.signal })
-    );
-  }
-  for (const prompt of plan.prompts) {
-    const name = prefixedName(plan.namespace, prompt.name);
-    if (host.hasPrompt(name)) {
-      proxyDiagnostic(
-        `Skipping proxied prompt "${name}" from upstream "${plan.namespace}" because that name is already registered`
-      );
-      continue;
-    }
-    const upstreamName = prompt.name;
-    host.registerPrompt(
-      {
-        name,
-        ...prompt.title !== void 0 && { title: prompt.title },
-        ...prompt.description !== void 0 && {
-          description: prompt.description
-        },
-        schema: passthroughJsonSchema(promptArgsToJsonSchema(prompt.arguments))
-      },
-      async (params) => plan.connection.getPrompt(upstreamName, params)
-    );
-  }
-}
-async function mountProxyConnection(host, connection) {
-  if (host.isStarted()) {
-    throw new Error(
-      "Cannot call proxy() after the server has started: register upstream servers before listen()/server.fetch."
-    );
-  }
-  const namespace = connection.info.server.name;
-  const plan = await introspect(namespace, connection);
-  mountPlan(host, plan);
-}
-function toClientConfig(config) {
-  return {
-    url: config.url,
-    ...config.headers !== void 0 && { headers: config.headers },
-    ...config.authToken !== void 0 && { authToken: config.authToken },
-    ...config.timeout !== void 0 && { timeout: config.timeout },
-    ...config.fetch !== void 0 && { fetch: config.fetch },
-    ...config.protocolNegotiation !== void 0 && {
-      protocolNegotiation: config.protocolNegotiation
-    },
-    oauth: false
-  };
-}
-async function mountProxyServers(host, servers) {
-  if (host.isStarted()) {
-    throw new Error(
-      "Cannot call proxy() after the server has started: register upstream servers before listen()/server.fetch."
-    );
-  }
-  const { MCPClient } = await loadProxyClient();
-  const clientServers = Object.fromEntries(
-    Object.entries(servers).map(([name, config]) => [
-      name,
-      toClientConfig(config)
-    ])
-  );
-  const owner = new MCPClient({ mcpServers: clientServers });
-  try {
-    const plans = [];
-    for (const namespace of Object.keys(clientServers)) {
-      let connection;
-      try {
-        connection = await owner.connect(namespace);
-      } catch (error) {
-        proxyDiagnostic(
-          `Failed to connect to upstream MCP server "${namespace}"`,
-          error
-        );
-        continue;
-      }
-      plans.push(await introspect(namespace, connection));
-    }
-    for (const plan of plans) mountPlan(host, plan);
-    host.trackOwner(owner);
-  } catch (error) {
-    await owner.close().catch(() => void 0);
-    throw error;
-  }
-}
-function isProxyConnection(value) {
-  return isConnection(value);
-}
-export {
-  isProxyConnection,
-  mountProxyConnection,
-  mountProxyServers,
-  proxyClientInstallError
-};

package/dist/public-route-BAMZRI4R.js

@@ -1,8 +0,0 @@
-import {
-  resolvePublicFilePath,
-  servePublicFile
-} from "./chunk-QCIREWRS.js";
-export {
-  resolvePublicFilePath,
-  servePublicFile
-};