@deimoscloud/coreai 0.1.0

package/src/adapters/mcp/client.ts

@@ -0,0 +1,451 @@
+/**
+ * MCP Client Wrapper
+ *
+ * Provides a simplified interface for connecting to and communicating with MCP servers.
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type {
+  McpServerConfig,
+  McpServerInfo,
+  McpTool,
+  McpResource,
+  McpToolResult,
+  McpCapabilities,
+  McpContent,
+  StdioServerConfig,
+} from './types.js';
+import { McpError } from './types.js';
+
+/**
+ * Options for creating an MCP client
+ */
+export interface McpClientOptions {
+  /**
+   * Client name to report to servers
+   */
+  clientName?: string;
+
+  /**
+   * Client version to report to servers
+   */
+  clientVersion?: string;
+
+  /**
+   * Timeout for operations in milliseconds
+   */
+  timeout?: number;
+}
+
+const DEFAULT_OPTIONS: Required<McpClientOptions> = {
+  clientName: 'coreai',
+  clientVersion: '0.1.0',
+  timeout: 30000,
+};
+
+/**
+ * MCP Client Wrapper
+ *
+ * Manages a connection to a single MCP server and provides
+ * a simplified API for tool calls, resource access, etc.
+ */
+export class McpClient {
+  private client: Client | null = null;
+  private transport: Transport | null = null;
+  private _serverInfo: McpServerInfo | null = null;
+  private options: Required<McpClientOptions>;
+  private serverName: string;
+  private config: McpServerConfig;
+
+  constructor(serverName: string, config: McpServerConfig, options?: McpClientOptions) {
+    this.serverName = serverName;
+    this.config = config;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+
+  /**
+   * Connect to the MCP server
+   */
+  async connect(): Promise<void> {
+    if (this.client && this.isConnected()) {
+      return;
+    }
+
+    try {
+      // Create the appropriate transport
+      this.transport = await this.createTransport();
+
+      // Create the MCP client
+      this.client = new Client(
+        {
+          name: this.options.clientName,
+          version: this.options.clientVersion,
+        },
+        {
+          capabilities: {
+            roots: { listChanged: true },
+          },
+        }
+      );
+
+      // Connect to the server
+      await this.client.connect(this.transport);
+
+      // Store server info
+      const serverVersion = this.client.getServerVersion();
+      const serverCapabilities = this.client.getServerCapabilities();
+
+      const info: McpServerInfo = {
+        name: this.serverName,
+        connected: true,
+      };
+
+      if (serverVersion?.version) {
+        info.version = serverVersion.version;
+      }
+
+      const caps = this.parseCapabilities(serverCapabilities);
+      if (caps) {
+        info.capabilities = caps;
+      }
+
+      const instructions = this.client.getInstructions();
+      if (instructions) {
+        info.instructions = instructions;
+      }
+
+      this._serverInfo = info;
+    } catch (error) {
+      throw new McpError(
+        `Failed to connect to MCP server "${this.serverName}": ${error instanceof Error ? error.message : String(error)}`,
+        'connection_failed',
+        this.serverName,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  /**
+   * Disconnect from the MCP server
+   */
+  async disconnect(): Promise<void> {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+
+    this.client = null;
+
+    if (this._serverInfo) {
+      this._serverInfo.connected = false;
+    }
+  }
+
+  /**
+   * Check if connected to the server
+   */
+  isConnected(): boolean {
+    return this._serverInfo?.connected ?? false;
+  }
+
+  /**
+   * Get server information
+   */
+  getServerInfo(): McpServerInfo | null {
+    return this._serverInfo;
+  }
+
+  /**
+   * List available tools from the server
+   */
+  async listTools(): Promise<McpTool[]> {
+    const client = this.ensureConnected();
+
+    const result = await client.listTools();
+
+    return result.tools.map((tool) => {
+      // Build inputSchema with only defined properties
+      const inputSchema: McpTool['inputSchema'] = { type: 'object' };
+      if (tool.inputSchema.properties) {
+        inputSchema.properties = tool.inputSchema.properties as Record<string, unknown>;
+      }
+      if (tool.inputSchema.required) {
+        inputSchema.required = tool.inputSchema.required;
+      }
+
+      const mapped: McpTool = {
+        name: tool.name,
+        inputSchema,
+      };
+
+      if (tool.description) {
+        mapped.description = tool.description;
+      }
+
+      if (tool.annotations) {
+        const annotations: McpTool['annotations'] = {};
+        if (tool.annotations.title) annotations.title = tool.annotations.title;
+        if (tool.annotations.readOnlyHint !== undefined)
+          annotations.readOnlyHint = tool.annotations.readOnlyHint;
+        if (tool.annotations.destructiveHint !== undefined)
+          annotations.destructiveHint = tool.annotations.destructiveHint;
+        if (tool.annotations.idempotentHint !== undefined)
+          annotations.idempotentHint = tool.annotations.idempotentHint;
+        if (Object.keys(annotations).length > 0) {
+          mapped.annotations = annotations;
+        }
+      }
+
+      return mapped;
+    });
+  }
+
+  /**
+   * Call a tool on the server
+   */
+  async callTool(name: string, args?: Record<string, unknown>): Promise<McpToolResult> {
+    const client = this.ensureConnected();
+
+    try {
+      const result = await client.callTool({
+        name,
+        arguments: args,
+      });
+
+      // Handle the different result formats
+      if ('content' in result && Array.isArray(result.content)) {
+        const content: McpContent[] = [];
+
+        for (const c of result.content) {
+          if (typeof c === 'object' && c !== null && 'type' in c) {
+            const item = c as { type: string; [key: string]: unknown };
+            if (item.type === 'text' && typeof item.text === 'string') {
+              content.push({ type: 'text', text: item.text });
+            } else if (
+              item.type === 'image' &&
+              typeof item.data === 'string' &&
+              typeof item.mimeType === 'string'
+            ) {
+              content.push({ type: 'image', data: item.data, mimeType: item.mimeType });
+            } else if (item.type === 'resource' && typeof item.resource === 'object') {
+              const res = item.resource as {
+                uri: string;
+                text?: string;
+                blob?: string;
+                mimeType?: string;
+              };
+              const resourceContent: {
+                uri: string;
+                text?: string;
+                blob?: string;
+                mimeType?: string;
+              } = {
+                uri: res.uri,
+              };
+              if (res.text) resourceContent.text = res.text;
+              if (res.blob) resourceContent.blob = res.blob;
+              if (res.mimeType) resourceContent.mimeType = res.mimeType;
+              content.push({
+                type: 'resource',
+                resource: resourceContent,
+              });
+            } else {
+              // Default to text for unknown types
+              content.push({ type: 'text', text: JSON.stringify(c) });
+            }
+          }
+        }
+
+        const toolResult: McpToolResult = { content };
+
+        if (typeof result.isError === 'boolean') {
+          toolResult.isError = result.isError;
+        }
+
+        if (typeof result.structuredContent === 'object' && result.structuredContent !== null) {
+          toolResult.structuredContent = result.structuredContent as Record<string, unknown>;
+        }
+
+        return toolResult;
+      }
+
+      // Handle legacy toolResult format
+      if ('toolResult' in result) {
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result.toolResult) }],
+        };
+      }
+
+      return {
+        content: [],
+      };
+    } catch (error) {
+      throw new McpError(
+        `Failed to call tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+        'protocol_error',
+        this.serverName,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  /**
+   * List available resources from the server
+   */
+  async listResources(): Promise<McpResource[]> {
+    const client = this.ensureConnected();
+
+    const result = await client.listResources();
+
+    return result.resources.map((resource) => {
+      const mapped: McpResource = {
+        uri: resource.uri,
+        name: resource.name,
+      };
+      if (resource.description) {
+        mapped.description = resource.description;
+      }
+      if (resource.mimeType) {
+        mapped.mimeType = resource.mimeType;
+      }
+      return mapped;
+    });
+  }
+
+  /**
+   * Read a resource from the server
+   */
+  async readResource(uri: string): Promise<string> {
+    const client = this.ensureConnected();
+
+    const result = await client.readResource({ uri });
+
+    // Return the first text content, or blob as base64
+    for (const content of result.contents) {
+      if ('text' in content) {
+        return content.text;
+      }
+      if ('blob' in content) {
+        return content.blob;
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * Create the appropriate transport for the server config
+   */
+  private async createTransport(): Promise<Transport> {
+    if (this.config.transport === 'stdio') {
+      return this.createStdioTransport(this.config);
+    }
+
+    // HTTP/SSE transports would be added here
+    throw new McpError(
+      `Unsupported transport type: ${this.config.transport}`,
+      'invalid_config',
+      this.serverName
+    );
+  }
+
+  /**
+   * Create a stdio transport for local MCP servers
+   */
+  private createStdioTransport(config: StdioServerConfig): Transport {
+    const params: {
+      command: string;
+      args?: string[];
+      env?: Record<string, string>;
+      cwd?: string;
+    } = {
+      command: config.command,
+    };
+
+    if (config.args) {
+      params.args = config.args;
+    }
+    if (config.env) {
+      params.env = config.env;
+    }
+    if (config.cwd) {
+      params.cwd = config.cwd;
+    }
+
+    return new StdioClientTransport(params);
+  }
+
+  /**
+   * Parse server capabilities into our format
+   */
+  private parseCapabilities(capabilities?: Record<string, unknown>): McpCapabilities | undefined {
+    if (!capabilities) return undefined;
+
+    return {
+      tools: !!capabilities.tools,
+      resources: !!capabilities.resources,
+      prompts: !!capabilities.prompts,
+      logging: !!capabilities.logging,
+    };
+  }
+
+  /**
+   * Ensure the client is connected and return the client instance
+   */
+  private ensureConnected(): Client {
+    if (!this.client || !this.isConnected()) {
+      throw new McpError(
+        `Not connected to MCP server "${this.serverName}"`,
+        'connection_closed',
+        this.serverName
+      );
+    }
+    return this.client;
+  }
+
+  /**
+   * Set server info (for mock/testing purposes)
+   */
+  protected setServerInfo(info: McpServerInfo): void {
+    this._serverInfo = info;
+  }
+}
+
+/**
+ * Create a mock MCP client for testing
+ */
+export function createMockMcpClient(
+  serverName: string,
+  tools: McpTool[] = [],
+  resources: McpResource[] = []
+): McpClient {
+  // Create a client with in-memory transport for testing
+  const client = new McpClient(serverName, { transport: 'stdio', command: 'mock' });
+
+  // Store mock data
+  const mockTools = tools;
+  const mockResources = resources;
+
+  // Override connect to set up mock state
+  client.connect = async function (this: McpClient) {
+    const info: McpServerInfo = {
+      name: serverName,
+      version: '1.0.0',
+      connected: true,
+      capabilities: { tools: true, resources: true },
+    };
+    (this as McpClient & { setServerInfo(info: McpServerInfo): void }).setServerInfo(info);
+  };
+
+  client.listTools = async function () {
+    return mockTools;
+  };
+
+  client.listResources = async function () {
+    return mockResources;
+  };
+
+  return client;
+}