@deimoscloud/coreai 0.1.8 → 0.1.10

package/src/adapters/mcp/client.ts

@@ -1,451 +0,0 @@
-/**
- * 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;
-}