@dexto/core 1.1.4 → 1.1.6

package/dist/mcp/mcp-client.js

@@ -0,0 +1,396 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { logger } from "../logger/index.js";
+import { resolveBundledScript } from "../utils/path.js";
+import { MCPError } from "./errors.js";
+class MCPClient {
+  client = null;
+  transport = null;
+  isConnected = false;
+  serverCommand = null;
+  originalArgs = null;
+  resolvedArgs = null;
+  serverEnv = null;
+  serverSpawned = false;
+  serverPid = null;
+  serverAlias = null;
+  timeout = 6e4;
+  // Default timeout value
+  async connect(config, serverName) {
+    this.timeout = config.timeout ?? 3e4;
+    if (config.type === "stdio") {
+      const stdioConfig = config;
+      let command = stdioConfig.command;
+      if (process.platform === "win32" && command === "npx") {
+        command = "C:\\Program Files\\nodejs\\npx.cmd";
+      }
+      return this.connectViaStdio(command, stdioConfig.args, stdioConfig.env, serverName);
+    } else if (config.type === "sse") {
+      const sseConfig = config;
+      return this.connectViaSSE(sseConfig.url, sseConfig.headers, serverName);
+    } else if (config.type === "http") {
+      const httpConfig = config;
+      return this.connectViaHttp(httpConfig.url, httpConfig.headers || {}, serverName);
+    } else {
+      const _exhaustive = config;
+      throw MCPError.protocolError(`Unsupported server type: ${JSON.stringify(_exhaustive)}`);
+    }
+  }
+  /**
+   * Connect to an MCP server via stdio
+   * @param command Command to run
+   * @param args Arguments for the command
+   * @param env Environment variables
+   * @param serverAlias Optional server alias/name to show in logs
+   */
+  async connectViaStdio(command, args = [], env, serverAlias) {
+    this.serverCommand = command;
+    this.originalArgs = [...args];
+    this.resolvedArgs = [...this.originalArgs];
+    this.serverEnv = env || null;
+    this.serverAlias = serverAlias || null;
+    if (command === "node" && this.resolvedArgs && this.resolvedArgs.length > 0 && this.resolvedArgs[0]?.startsWith("dist/")) {
+      try {
+        const scriptRelativePath = this.resolvedArgs[0];
+        this.resolvedArgs[0] = resolveBundledScript(scriptRelativePath);
+        logger.debug(
+          `Resolved bundled script path: ${scriptRelativePath} -> ${this.resolvedArgs[0]}`
+        );
+      } catch (e) {
+        logger.warn(
+          `Failed to resolve path for bundled script ${this.resolvedArgs[0]}: ${JSON.stringify(e, null, 2)}`
+        );
+      }
+    }
+    logger.info("=======================================");
+    logger.info(`MCP SERVER: ${command} ${this.resolvedArgs.join(" ")}`, null, "magenta");
+    if (env) {
+      logger.info("Environment:");
+      Object.entries(env).forEach(([key, _]) => {
+        logger.info(`  ${key}= [value hidden]`);
+      });
+    }
+    logger.info("=======================================\n");
+    const serverName = this.serverAlias ? `"${this.serverAlias}" (${command} ${this.resolvedArgs.join(" ")})` : `${command} ${this.resolvedArgs.join(" ")}`;
+    logger.info(`Connecting to MCP server: ${serverName}`);
+    const expandedEnv = {
+      ...process.env,
+      ...env || {}
+    };
+    this.transport = new StdioClientTransport({
+      command,
+      args: this.resolvedArgs,
+      env: expandedEnv
+    });
+    this.client = new Client(
+      {
+        name: "Dexto-stdio-mcp-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: { tools: {} }
+      }
+    );
+    try {
+      logger.info("Establishing connection...");
+      await this.client.connect(this.transport);
+      this.serverSpawned = true;
+      logger.info(`\u2705 Stdio SERVER ${serverName} SPAWNED`);
+      logger.info("Connection established!\n\n");
+      this.isConnected = true;
+      return this.client;
+    } catch (error) {
+      logger.error(
+        `Failed to connect to MCP server ${serverName}: ${JSON.stringify(error.message, null, 2)}`
+      );
+      throw error;
+    }
+  }
+  async connectViaSSE(url, headers = {}, serverName) {
+    logger.debug(`Connecting to SSE MCP server at url: ${url}`);
+    this.transport = new SSEClientTransport(new URL(url), {
+      // For regular HTTP requests
+      requestInit: {
+        headers
+      }
+      // Need to implement eventSourceInit for SSE events.
+    });
+    logger.debug(`[connectViaSSE] SSE transport: ${JSON.stringify(this.transport, null, 2)}`);
+    this.client = new Client(
+      {
+        name: "Dexto-sse-mcp-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: { tools: {} }
+      }
+    );
+    try {
+      logger.info("Establishing connection...");
+      await this.client.connect(this.transport);
+      this.serverSpawned = true;
+      logger.info(`\u2705 ${serverName} SSE SERVER SPAWNED`);
+      logger.info("Connection established!\n\n");
+      this.isConnected = true;
+      return this.client;
+    } catch (error) {
+      logger.error(
+        `Failed to connect to SSE MCP server ${url}: ${JSON.stringify(error.message, null, 2)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Connect to an MCP server via Streamable HTTP transport
+   */
+  async connectViaHttp(url, headers = {}, serverAlias) {
+    logger.info(`Connecting to HTTP MCP server at ${url}`);
+    this.transport = new StreamableHTTPClientTransport(new URL(url), {
+      requestInit: { headers: headers || {} }
+    });
+    this.client = new Client(
+      { name: "Dexto-http-mcp-client", version: "1.0.0" },
+      { capabilities: { tools: {} } }
+    );
+    try {
+      logger.info("Establishing HTTP connection...");
+      await this.client.connect(this.transport);
+      this.isConnected = true;
+      logger.info(`\u2705 HTTP SERVER ${serverAlias ?? url} CONNECTED`);
+      return this.client;
+    } catch (error) {
+      logger.error(
+        `Failed to connect to HTTP MCP server ${url}: ${JSON.stringify(error.message, null, 2)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the server
+   */
+  async disconnect() {
+    if (this.transport && typeof this.transport.close === "function") {
+      try {
+        await this.transport.close();
+        this.isConnected = false;
+        this.serverSpawned = false;
+        logger.info("Disconnected from MCP server");
+      } catch (error) {
+        logger.error(
+          `Error disconnecting from MCP server: ${JSON.stringify(error.message, null, 2)}`
+        );
+      }
+    }
+  }
+  /**
+   * Call a tool with given name and arguments
+   * @param name Tool name
+   * @param args Tool arguments
+   * @returns Result of the tool execution
+   */
+  async callTool(name, args) {
+    this.ensureConnected();
+    try {
+      logger.debug(`Calling tool '${name}' with args: ${JSON.stringify(args, null, 2)}`);
+      let toolArgs = args;
+      if (typeof args === "string") {
+        try {
+          toolArgs = JSON.parse(args);
+        } catch {
+          toolArgs = { input: args };
+        }
+      }
+      logger.debug(`Using timeout: ${this.timeout}`);
+      const result = await this.client.callTool(
+        { name, arguments: toolArgs },
+        void 0,
+        // resultSchema (optional)
+        { timeout: this.timeout }
+        // Use server-specific timeout, default 1 minute
+      );
+      const logResult = JSON.stringify(
+        result,
+        (key, value) => {
+          if (key === "data" && typeof value === "string" && value.length > 100) {
+            return `[Base64 data: ${value.length} chars]`;
+          }
+          return value;
+        },
+        2
+      );
+      logger.debug(`Tool '${name}' result: ${logResult}`);
+      if (result === null || result === void 0) {
+        return "Tool executed successfully with no result data.";
+      }
+      return result;
+    } catch (error) {
+      logger.error(`Tool call '${name}' failed: ${JSON.stringify(error, null, 2)}`);
+      return `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  /**
+   * Get the list of tools provided by this client
+   * @returns Array of available tools
+   */
+  async getTools() {
+    this.ensureConnected();
+    const tools = {};
+    try {
+      const listToolResult = await this.client.listTools({});
+      logger.silly(`listTools result: ${JSON.stringify(listToolResult, null, 2)}`);
+      if (listToolResult && listToolResult.tools) {
+        listToolResult.tools.forEach((tool) => {
+          if (!tool.description) {
+            logger.warn(`Tool '${tool.name}' is missing a description`);
+          }
+          if (!tool.inputSchema) {
+            throw MCPError.invalidToolSchema(tool.name, "missing input schema");
+          }
+          tools[tool.name] = {
+            description: tool.description ?? "",
+            parameters: tool.inputSchema
+          };
+        });
+      } else {
+        throw MCPError.protocolError(
+          "listTools did not return the expected structure: missing tools"
+        );
+      }
+    } catch (error) {
+      logger.warn(
+        `Failed to get tools from MCP server, proceeding with zero tools: ${JSON.stringify(error, null, 2)}`
+      );
+      return tools;
+    }
+    return tools;
+  }
+  /**
+   * Get the list of prompts provided by this client
+   * @returns Array of available prompt names
+   * TODO: Turn exception logs back into error and only call this based on capabilities of the server
+   */
+  async listPrompts() {
+    this.ensureConnected();
+    try {
+      const response = await this.client.listPrompts();
+      logger.debug(`listPrompts response: ${JSON.stringify(response, null, 2)}`);
+      return response.prompts.map((p) => p.name);
+    } catch (error) {
+      logger.debug(
+        `Failed to list prompts from MCP server (optional feature), skipping: ${JSON.stringify(error, null, 2)}`
+      );
+      return [];
+    }
+  }
+  /**
+   * Get a specific prompt definition
+   * @param name Name of the prompt
+   * @param args Arguments for the prompt (optional)
+   * @returns Prompt definition (structure depends on SDK)
+   * TODO: Turn exception logs back into error and only call this based on capabilities of the server
+   */
+  async getPrompt(name, args) {
+    this.ensureConnected();
+    try {
+      logger.debug(`Getting prompt '${name}' with args: ${JSON.stringify(args, null, 2)}`);
+      const response = await this.client.getPrompt(
+        { name, arguments: args },
+        { timeout: this.timeout }
+      );
+      logger.debug(`getPrompt '${name}' response: ${JSON.stringify(response, null, 2)}`);
+      return response;
+    } catch (error) {
+      logger.debug(
+        `Failed to get prompt '${name}' from MCP server: ${JSON.stringify(error, null, 2)}`
+      );
+      throw MCPError.protocolError(
+        `Error getting prompt '${name}': ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get the list of resources provided by this client
+   * @returns Array of available resource URIs
+   * TODO: Turn exception logs back into error and only call this based on capabilities of the server
+   */
+  async listResources() {
+    this.ensureConnected();
+    try {
+      const response = await this.client.listResources();
+      logger.debug(`listResources response: ${JSON.stringify(response, null, 2)}`);
+      return response.resources.map((r) => r.uri);
+    } catch (error) {
+      logger.debug(
+        `Failed to list resources from MCP server (optional feature), skipping: ${JSON.stringify(error, null, 2)}`
+      );
+      return [];
+    }
+  }
+  /**
+   * Read the content of a specific resource
+   * @param uri URI of the resource
+   * @returns Content of the resource (structure depends on SDK)
+   */
+  async readResource(uri) {
+    this.ensureConnected();
+    try {
+      logger.debug(`Reading resource '${uri}'`);
+      const response = await this.client.readResource({ uri }, { timeout: this.timeout });
+      logger.debug(`readResource '${uri}' response: ${JSON.stringify(response, null, 2)}`);
+      return response;
+    } catch (error) {
+      logger.debug(
+        `Failed to read resource '${uri}' from MCP server: ${JSON.stringify(error, null, 2)}`
+      );
+      throw MCPError.protocolError(
+        `Error reading resource '${uri}': ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if the client is connected
+   */
+  getConnectionStatus() {
+    return this.isConnected;
+  }
+  /**
+   * Get the connected client
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get server status information
+   */
+  getServerInfo() {
+    return {
+      spawned: this.serverSpawned,
+      pid: this.serverPid,
+      command: this.serverCommand,
+      originalArgs: this.originalArgs,
+      resolvedArgs: this.resolvedArgs,
+      env: this.serverEnv,
+      alias: this.serverAlias
+    };
+  }
+  /**
+   * Get the client instance once connected
+   * @returns Promise with the MCP client
+   */
+  async getConnectedClient() {
+    if (!this.client || !this.isConnected) {
+      throw MCPError.clientNotConnected();
+    }
+    return this.client;
+  }
+  ensureConnected() {
+    if (!this.isConnected || !this.client) {
+      throw MCPError.clientNotConnected("Please call connect() first");
+    }
+  }
+}
+export {
+  MCPClient
+};

package/dist/mcp/resolver.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolver_exports = {};
+__export(resolver_exports, {
+  resolveAndValidateMcpServerConfig: () => resolveAndValidateMcpServerConfig
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_result = require("../utils/result.js");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+var import_schemas = require("./schemas.js");
+function resolveAndValidateMcpServerConfig(serverName, serverConfig, existingServerNames = []) {
+  const { candidate, warnings } = resolveMcpServerConfig(
+    serverName,
+    serverConfig,
+    existingServerNames
+  );
+  if ((0, import_result.hasErrors)(warnings)) {
+    return (0, import_result.fail)(warnings);
+  }
+  return validateMcpServerConfig(candidate, warnings);
+}
+function resolveMcpServerConfig(serverName, candidate, existingServerNames) {
+  const warnings = [];
+  if (typeof serverName !== "string" || serverName.trim() === "") {
+    warnings.push({
+      code: import_error_codes.MCPErrorCode.SCHEMA_VALIDATION,
+      message: "Server name must be a non-empty string",
+      severity: "error",
+      scope: import_types.ErrorScope.MCP,
+      type: import_types.ErrorType.USER,
+      context: { serverName }
+    });
+  }
+  const dup = existingServerNames.find(
+    (n) => n.toLowerCase() === serverName.toLowerCase() && n !== serverName
+  );
+  if (dup) {
+    warnings.push({
+      code: import_error_codes.MCPErrorCode.DUPLICATE_NAME,
+      message: `Server name '${serverName}' is similar to existing '${dup}' (case differs)`,
+      severity: "warning",
+      scope: import_types.ErrorScope.MCP,
+      type: import_types.ErrorType.USER,
+      context: { serverName }
+    });
+  }
+  return { candidate, warnings };
+}
+function validateMcpServerConfig(candidate, warnings) {
+  const parsed = import_schemas.McpServerConfigSchema.safeParse(candidate);
+  if (!parsed.success) {
+    return (0, import_result.fail)(
+      (0, import_result.zodToIssues)(parsed.error, "error")
+    );
+  }
+  return (0, import_result.ok)(parsed.data, warnings);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAndValidateMcpServerConfig
+});

package/dist/mcp/resolver.d.cts

@@ -0,0 +1,22 @@
+import { Result } from '../utils/result.cjs';
+import { McpServerConfig, ValidatedMcpServerConfig } from './schemas.cjs';
+import 'zod';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import './error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+
+type McpServerContext = {
+    serverName?: string;
+};
+declare function resolveAndValidateMcpServerConfig(serverName: string, serverConfig: McpServerConfig, existingServerNames?: string[]): Result<ValidatedMcpServerConfig, McpServerContext>;
+
+export { type McpServerContext, resolveAndValidateMcpServerConfig };

package/dist/mcp/resolver.d.ts

@@ -0,0 +1,22 @@
+import { Result } from '../utils/result.js';
+import { McpServerConfig, ValidatedMcpServerConfig } from './schemas.js';
+import 'zod';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import './error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+
+type McpServerContext = {
+    serverName?: string;
+};
+declare function resolveAndValidateMcpServerConfig(serverName: string, serverConfig: McpServerConfig, existingServerNames?: string[]): Result<ValidatedMcpServerConfig, McpServerContext>;
+
+export { type McpServerContext, resolveAndValidateMcpServerConfig };

package/dist/mcp/resolver.js

@@ -0,0 +1,56 @@
+import { ok, fail, hasErrors, zodToIssues } from "../utils/result.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { MCPErrorCode } from "./error-codes.js";
+import {
+  McpServerConfigSchema
+} from "./schemas.js";
+function resolveAndValidateMcpServerConfig(serverName, serverConfig, existingServerNames = []) {
+  const { candidate, warnings } = resolveMcpServerConfig(
+    serverName,
+    serverConfig,
+    existingServerNames
+  );
+  if (hasErrors(warnings)) {
+    return fail(warnings);
+  }
+  return validateMcpServerConfig(candidate, warnings);
+}
+function resolveMcpServerConfig(serverName, candidate, existingServerNames) {
+  const warnings = [];
+  if (typeof serverName !== "string" || serverName.trim() === "") {
+    warnings.push({
+      code: MCPErrorCode.SCHEMA_VALIDATION,
+      message: "Server name must be a non-empty string",
+      severity: "error",
+      scope: ErrorScope.MCP,
+      type: ErrorType.USER,
+      context: { serverName }
+    });
+  }
+  const dup = existingServerNames.find(
+    (n) => n.toLowerCase() === serverName.toLowerCase() && n !== serverName
+  );
+  if (dup) {
+    warnings.push({
+      code: MCPErrorCode.DUPLICATE_NAME,
+      message: `Server name '${serverName}' is similar to existing '${dup}' (case differs)`,
+      severity: "warning",
+      scope: ErrorScope.MCP,
+      type: ErrorType.USER,
+      context: { serverName }
+    });
+  }
+  return { candidate, warnings };
+}
+function validateMcpServerConfig(candidate, warnings) {
+  const parsed = McpServerConfigSchema.safeParse(candidate);
+  if (!parsed.success) {
+    return fail(
+      zodToIssues(parsed.error, "error")
+    );
+  }
+  return ok(parsed.data, warnings);
+}
+export {
+  resolveAndValidateMcpServerConfig
+};

package/dist/mcp/schemas.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  HttpServerConfigSchema: () => HttpServerConfigSchema,
+  McpServerConfigSchema: () => McpServerConfigSchema,
+  ServerConfigsSchema: () => ServerConfigsSchema,
+  SseServerConfigSchema: () => SseServerConfigSchema,
+  StdioServerConfigSchema: () => StdioServerConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_error_codes = require("./error-codes.js");
+var import_types = require("../errors/types.cjs");
+var import_result = require("../utils/result.cjs");
+var import_zod = require("zod");
+const StdioServerConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("stdio"),
+  // allow env in command & args if you want; remove EnvExpandedString if not desired
+  command: (0, import_result.EnvExpandedString)().superRefine((s, ctx) => {
+    if (s.length === 0) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        message: "Stdio server requires a non-empty command",
+        params: {
+          code: import_error_codes.MCPErrorCode.COMMAND_MISSING,
+          scope: import_types.ErrorScope.MCP,
+          type: import_types.ErrorType.USER
+        },
+        path: ["command"]
+      });
+    }
+  }),
+  args: import_zod.z.array((0, import_result.EnvExpandedString)()).default([]).describe("Array of arguments for the command (e.g., ['script.js'])"),
+  env: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}).describe("Optional environment variables for the server process"),
+  timeout: import_zod.z.coerce.number().int().positive().default(3e4),
+  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+}).strict();
+const SseServerConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("sse"),
+  url: (0, import_result.RequiredEnvURL)(process.env).describe("URL for the SSE server endpoint"),
+  headers: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}),
+  timeout: import_zod.z.coerce.number().int().positive().default(3e4),
+  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+}).strict();
+const HttpServerConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("http"),
+  url: (0, import_result.RequiredEnvURL)(process.env).describe("URL for the HTTP server"),
+  headers: import_zod.z.record((0, import_result.EnvExpandedString)()).default({}),
+  timeout: import_zod.z.coerce.number().int().positive().default(3e4),
+  connectionMode: import_zod.z.enum(["strict", "lenient"]).default("lenient")
+}).strict();
+const McpServerConfigSchema = import_zod.z.discriminatedUnion("type", [
+  StdioServerConfigSchema,
+  SseServerConfigSchema,
+  HttpServerConfigSchema
+]).superRefine((_data, _ctx) => {
+}).brand();
+const ServerConfigsSchema = import_zod.z.record(McpServerConfigSchema).describe("A dictionary of server configurations, keyed by server name").brand();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpServerConfigSchema,
+  McpServerConfigSchema,
+  ServerConfigsSchema,
+  SseServerConfigSchema,
+  StdioServerConfigSchema
+});