@dexto/core 1.1.4 → 1.1.6

package/dist/mcp/mcp-client.cjs

@@ -0,0 +1,420 @@
+"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 mcp_client_exports = {};
+__export(mcp_client_exports, {
+  MCPClient: () => MCPClient
+});
+module.exports = __toCommonJS(mcp_client_exports);
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_logger = require("../logger/index.js");
+var import_path = require("../utils/path.js");
+var import_errors = require("./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 import_errors.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] = (0, import_path.resolveBundledScript)(scriptRelativePath);
+        import_logger.logger.debug(
+          `Resolved bundled script path: ${scriptRelativePath} -> ${this.resolvedArgs[0]}`
+        );
+      } catch (e) {
+        import_logger.logger.warn(
+          `Failed to resolve path for bundled script ${this.resolvedArgs[0]}: ${JSON.stringify(e, null, 2)}`
+        );
+      }
+    }
+    import_logger.logger.info("=======================================");
+    import_logger.logger.info(`MCP SERVER: ${command} ${this.resolvedArgs.join(" ")}`, null, "magenta");
+    if (env) {
+      import_logger.logger.info("Environment:");
+      Object.entries(env).forEach(([key, _]) => {
+        import_logger.logger.info(`  ${key}= [value hidden]`);
+      });
+    }
+    import_logger.logger.info("=======================================\n");
+    const serverName = this.serverAlias ? `"${this.serverAlias}" (${command} ${this.resolvedArgs.join(" ")})` : `${command} ${this.resolvedArgs.join(" ")}`;
+    import_logger.logger.info(`Connecting to MCP server: ${serverName}`);
+    const expandedEnv = {
+      ...process.env,
+      ...env || {}
+    };
+    this.transport = new import_stdio.StdioClientTransport({
+      command,
+      args: this.resolvedArgs,
+      env: expandedEnv
+    });
+    this.client = new import_client.Client(
+      {
+        name: "Dexto-stdio-mcp-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: { tools: {} }
+      }
+    );
+    try {
+      import_logger.logger.info("Establishing connection...");
+      await this.client.connect(this.transport);
+      this.serverSpawned = true;
+      import_logger.logger.info(`\u2705 Stdio SERVER ${serverName} SPAWNED`);
+      import_logger.logger.info("Connection established!\n\n");
+      this.isConnected = true;
+      return this.client;
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to connect to MCP server ${serverName}: ${JSON.stringify(error.message, null, 2)}`
+      );
+      throw error;
+    }
+  }
+  async connectViaSSE(url, headers = {}, serverName) {
+    import_logger.logger.debug(`Connecting to SSE MCP server at url: ${url}`);
+    this.transport = new import_sse.SSEClientTransport(new URL(url), {
+      // For regular HTTP requests
+      requestInit: {
+        headers
+      }
+      // Need to implement eventSourceInit for SSE events.
+    });
+    import_logger.logger.debug(`[connectViaSSE] SSE transport: ${JSON.stringify(this.transport, null, 2)}`);
+    this.client = new import_client.Client(
+      {
+        name: "Dexto-sse-mcp-client",
+        version: "1.0.0"
+      },
+      {
+        capabilities: { tools: {} }
+      }
+    );
+    try {
+      import_logger.logger.info("Establishing connection...");
+      await this.client.connect(this.transport);
+      this.serverSpawned = true;
+      import_logger.logger.info(`\u2705 ${serverName} SSE SERVER SPAWNED`);
+      import_logger.logger.info("Connection established!\n\n");
+      this.isConnected = true;
+      return this.client;
+    } catch (error) {
+      import_logger.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) {
+    import_logger.logger.info(`Connecting to HTTP MCP server at ${url}`);
+    this.transport = new import_streamableHttp.StreamableHTTPClientTransport(new URL(url), {
+      requestInit: { headers: headers || {} }
+    });
+    this.client = new import_client.Client(
+      { name: "Dexto-http-mcp-client", version: "1.0.0" },
+      { capabilities: { tools: {} } }
+    );
+    try {
+      import_logger.logger.info("Establishing HTTP connection...");
+      await this.client.connect(this.transport);
+      this.isConnected = true;
+      import_logger.logger.info(`\u2705 HTTP SERVER ${serverAlias ?? url} CONNECTED`);
+      return this.client;
+    } catch (error) {
+      import_logger.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;
+        import_logger.logger.info("Disconnected from MCP server");
+      } catch (error) {
+        import_logger.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 {
+      import_logger.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 };
+        }
+      }
+      import_logger.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
+      );
+      import_logger.logger.debug(`Tool '${name}' result: ${logResult}`);
+      if (result === null || result === void 0) {
+        return "Tool executed successfully with no result data.";
+      }
+      return result;
+    } catch (error) {
+      import_logger.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({});
+      import_logger.logger.silly(`listTools result: ${JSON.stringify(listToolResult, null, 2)}`);
+      if (listToolResult && listToolResult.tools) {
+        listToolResult.tools.forEach((tool) => {
+          if (!tool.description) {
+            import_logger.logger.warn(`Tool '${tool.name}' is missing a description`);
+          }
+          if (!tool.inputSchema) {
+            throw import_errors.MCPError.invalidToolSchema(tool.name, "missing input schema");
+          }
+          tools[tool.name] = {
+            description: tool.description ?? "",
+            parameters: tool.inputSchema
+          };
+        });
+      } else {
+        throw import_errors.MCPError.protocolError(
+          "listTools did not return the expected structure: missing tools"
+        );
+      }
+    } catch (error) {
+      import_logger.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();
+      import_logger.logger.debug(`listPrompts response: ${JSON.stringify(response, null, 2)}`);
+      return response.prompts.map((p) => p.name);
+    } catch (error) {
+      import_logger.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 {
+      import_logger.logger.debug(`Getting prompt '${name}' with args: ${JSON.stringify(args, null, 2)}`);
+      const response = await this.client.getPrompt(
+        { name, arguments: args },
+        { timeout: this.timeout }
+      );
+      import_logger.logger.debug(`getPrompt '${name}' response: ${JSON.stringify(response, null, 2)}`);
+      return response;
+    } catch (error) {
+      import_logger.logger.debug(
+        `Failed to get prompt '${name}' from MCP server: ${JSON.stringify(error, null, 2)}`
+      );
+      throw import_errors.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();
+      import_logger.logger.debug(`listResources response: ${JSON.stringify(response, null, 2)}`);
+      return response.resources.map((r) => r.uri);
+    } catch (error) {
+      import_logger.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 {
+      import_logger.logger.debug(`Reading resource '${uri}'`);
+      const response = await this.client.readResource({ uri }, { timeout: this.timeout });
+      import_logger.logger.debug(`readResource '${uri}' response: ${JSON.stringify(response, null, 2)}`);
+      return response;
+    } catch (error) {
+      import_logger.logger.debug(
+        `Failed to read resource '${uri}' from MCP server: ${JSON.stringify(error, null, 2)}`
+      );
+      throw import_errors.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 import_errors.MCPError.clientNotConnected();
+    }
+    return this.client;
+  }
+  ensureConnected() {
+    if (!this.isConnected || !this.client) {
+      throw import_errors.MCPError.clientNotConnected("Please call connect() first");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPClient
+});

package/dist/mcp/mcp-client.d.cts

@@ -0,0 +1,108 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { ValidatedMcpServerConfig } from './schemas.cjs';
+import { ToolSet } from '../tools/types.cjs';
+import { IMCPClient } from './types.cjs';
+import { GetPromptResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'json-schema';
+
+/**
+ * Wrapper on top of Client class provided in model context protocol SDK, to add additional metadata about the server
+ */
+declare class MCPClient implements IMCPClient {
+    private client;
+    private transport;
+    private isConnected;
+    private serverCommand;
+    private originalArgs;
+    private resolvedArgs;
+    private serverEnv;
+    private serverSpawned;
+    private serverPid;
+    private serverAlias;
+    private timeout;
+    connect(config: ValidatedMcpServerConfig, serverName: string): Promise<Client>;
+    /**
+     * 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
+     */
+    connectViaStdio(command: string, args?: string[], env?: Record<string, string>, serverAlias?: string): Promise<Client>;
+    connectViaSSE(url: string, headers: Record<string, string> | undefined, serverName: string): Promise<Client>;
+    /**
+     * Connect to an MCP server via Streamable HTTP transport
+     */
+    private connectViaHttp;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Call a tool with given name and arguments
+     * @param name Tool name
+     * @param args Tool arguments
+     * @returns Result of the tool execution
+     */
+    callTool(name: string, args: any): Promise<any>;
+    /**
+     * Get the list of tools provided by this client
+     * @returns Array of available tools
+     */
+    getTools(): Promise<ToolSet>;
+    /**
+     * 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
+     */
+    listPrompts(): Promise<string[]>;
+    /**
+     * 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
+     */
+    getPrompt(name: string, args?: any): Promise<GetPromptResult>;
+    /**
+     * 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
+     */
+    listResources(): Promise<string[]>;
+    /**
+     * Read the content of a specific resource
+     * @param uri URI of the resource
+     * @returns Content of the resource (structure depends on SDK)
+     */
+    readResource(uri: string): Promise<ReadResourceResult>;
+    /**
+     * Check if the client is connected
+     */
+    getConnectionStatus(): boolean;
+    /**
+     * Get the connected client
+     */
+    getClient(): Client | null;
+    /**
+     * Get server status information
+     */
+    getServerInfo(): {
+        spawned: boolean;
+        pid: number | null;
+        command: string | null;
+        originalArgs: string[] | null;
+        resolvedArgs: string[] | null;
+        env: Record<string, string> | null;
+        alias: string | null;
+    };
+    /**
+     * Get the client instance once connected
+     * @returns Promise with the MCP client
+     */
+    getConnectedClient(): Promise<Client>;
+    private ensureConnected;
+}
+
+export { MCPClient };

package/dist/mcp/mcp-client.d.ts

@@ -0,0 +1,108 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { ValidatedMcpServerConfig } from './schemas.js';
+import { ToolSet } from '../tools/types.js';
+import { IMCPClient } from './types.js';
+import { GetPromptResult, ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'json-schema';
+
+/**
+ * Wrapper on top of Client class provided in model context protocol SDK, to add additional metadata about the server
+ */
+declare class MCPClient implements IMCPClient {
+    private client;
+    private transport;
+    private isConnected;
+    private serverCommand;
+    private originalArgs;
+    private resolvedArgs;
+    private serverEnv;
+    private serverSpawned;
+    private serverPid;
+    private serverAlias;
+    private timeout;
+    connect(config: ValidatedMcpServerConfig, serverName: string): Promise<Client>;
+    /**
+     * 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
+     */
+    connectViaStdio(command: string, args?: string[], env?: Record<string, string>, serverAlias?: string): Promise<Client>;
+    connectViaSSE(url: string, headers: Record<string, string> | undefined, serverName: string): Promise<Client>;
+    /**
+     * Connect to an MCP server via Streamable HTTP transport
+     */
+    private connectViaHttp;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Call a tool with given name and arguments
+     * @param name Tool name
+     * @param args Tool arguments
+     * @returns Result of the tool execution
+     */
+    callTool(name: string, args: any): Promise<any>;
+    /**
+     * Get the list of tools provided by this client
+     * @returns Array of available tools
+     */
+    getTools(): Promise<ToolSet>;
+    /**
+     * 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
+     */
+    listPrompts(): Promise<string[]>;
+    /**
+     * 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
+     */
+    getPrompt(name: string, args?: any): Promise<GetPromptResult>;
+    /**
+     * 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
+     */
+    listResources(): Promise<string[]>;
+    /**
+     * Read the content of a specific resource
+     * @param uri URI of the resource
+     * @returns Content of the resource (structure depends on SDK)
+     */
+    readResource(uri: string): Promise<ReadResourceResult>;
+    /**
+     * Check if the client is connected
+     */
+    getConnectionStatus(): boolean;
+    /**
+     * Get the connected client
+     */
+    getClient(): Client | null;
+    /**
+     * Get server status information
+     */
+    getServerInfo(): {
+        spawned: boolean;
+        pid: number | null;
+        command: string | null;
+        originalArgs: string[] | null;
+        resolvedArgs: string[] | null;
+        env: Record<string, string> | null;
+        alias: string | null;
+    };
+    /**
+     * Get the client instance once connected
+     * @returns Promise with the MCP client
+     */
+    getConnectedClient(): Promise<Client>;
+    private ensureConnected;
+}
+
+export { MCPClient };