@autonomaai/mcp-client 1.0.0

package/src/client.ts

@@ -0,0 +1,780 @@
+/**
+ * Unified MCP Client for autonoma Trading System
+ * 
+ * This client provides a unified interface for interacting with MCP servers
+ * across the autonoma ecosystem, with support for connection pooling,
+ * error handling, retries, and both sync and async operations.
+ */
+
+// Use native fetch (Node.js 18+) or polyfill
+declare const fetch: typeof globalThis.fetch;
+import { 
+  MCPClientConfig, 
+  MCPClientOptions,
+  HummingbotHealthResponse,
+  HummingbotContext,
+  CreateControllerRequest,
+  ControllerResponse,
+  ControllerMetrics,
+  ExchangeListResponse,
+  ConnectExchangeRequest,
+  TradingConnectionResponse,
+  MarketDataResponse,
+  ExecuteSignalRequest,
+  SignalExecutionResponse,
+  CreateBotRequest,
+  BotResponse,
+  CreatePoolRequest,
+  PoolResponse,
+  ConfigurationObject,
+  HyperliquidOrderbook,
+  HyperliquidSummary,
+  ErrorResponse,
+  MCPRequest,
+  MCPResponse,
+  MCPToolsListResponse,
+  MCPToolCallRequest,
+  MCPToolCallResponse
+} from './types';
+
+/**
+ * HTTP Client Error for MCP operations
+ */
+export class MCPClientError extends Error {
+  constructor(
+    message: string, 
+    public status?: number, 
+    public response?: any
+  ) {
+    super(message);
+    this.name = 'MCPClientError';
+  }
+}
+
+/**
+ * Main MCP Client class
+ */
+export class MCPClient {
+  private config: Required<MCPClientConfig>;
+  private headers: Record<string, string>;
+
+  constructor(config: MCPClientConfig) {
+    this.config = {
+      timeout: 30000,
+      retries: 3,
+      retryDelay: 1000,
+      enableLogging: false,
+      apiKey: '',
+      headers: {},
+      ...config
+    };
+
+    this.headers = {
+      'Content-Type': 'application/json',
+      'User-Agent': '@autonoma/mcp-client/1.0.0',
+      ...this.config.headers
+    };
+
+    if (this.config.apiKey) {
+      this.headers['Authorization'] = `Bearer ${this.config.apiKey}`;
+    }
+  }
+
+  /**
+   * Make HTTP request with retry logic and error handling
+   */
+  private async request<T>(
+    endpoint: string, 
+    options: MCPClientOptions & {
+      method?: string;
+      body?: any;
+    } = {}
+  ): Promise<T> {
+    const {
+      method = 'GET',
+      body,
+      timeout = this.config.timeout,
+      retries = this.config.retries,
+      retryDelay = this.config.retryDelay,
+      headers: optionHeaders = {}
+    } = options;
+
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const requestHeaders = { ...this.headers, ...optionHeaders };
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        if (this.config.enableLogging && attempt > 0) {
+          // Use structured logging format instead of plain console.log
+          const logEntry = {
+            timestamp: new Date().toISOString(),
+            level: 'INFO',
+            component: 'MCP Client',
+            message: 'Retry attempt',
+            attempt,
+            method,
+            url
+          };
+          
+          // @ts-ignore - process may not be available in all environments
+          const isProduction = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production';
+          if (isProduction) {
+            console.log(JSON.stringify(logEntry));
+          } else {
+            console.log(`[${logEntry.timestamp}] ${logEntry.level} [${logEntry.component}] ${logEntry.message} - attempt ${attempt} for ${method} ${url}`);
+          }
+        }
+
+        const response = await fetch(url, {
+          method,
+          headers: requestHeaders,
+          body: body ? JSON.stringify(body) : undefined,
+          // @ts-ignore - node-fetch timeout type issue
+          timeout
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          let errorData: ErrorResponse | null = null;
+          
+          try {
+            errorData = JSON.parse(errorText);
+          } catch {
+            // Not JSON, use plain text
+          }
+
+          const errorMessage = errorData?.error || `HTTP ${response.status}: ${response.statusText}`;
+          throw new MCPClientError(
+            errorMessage,
+            response.status,
+            errorData
+          );
+        }
+
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+          return await response.json() as T;
+        } else {
+          return await response.text() as unknown as T;
+        }
+
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        
+        if (this.config.enableLogging) {
+          console.error(`MCP Client: Request failed (attempt ${attempt + 1}):`, lastError.message);
+        }
+
+        // Don't retry on client errors (4xx) or final attempt
+        if (error instanceof MCPClientError && error.status && error.status < 500) {
+          break;
+        }
+        
+        if (attempt === retries) {
+          break;
+        }
+
+        // Wait before retry
+        await new Promise(resolve => setTimeout(resolve, retryDelay * Math.pow(2, attempt)));
+      }
+    }
+
+    throw lastError || new MCPClientError('Request failed after all retries');
+  }
+
+  // =============================================================================
+  // Health and Context Methods
+  // =============================================================================
+
+  async getHealth(): Promise<HummingbotHealthResponse> {
+    return this.request<HummingbotHealthResponse>('/health');
+  }
+
+  async getContext(): Promise<HummingbotContext> {
+    return this.request<HummingbotContext>('/context');
+  }
+
+  // =============================================================================
+  // Controller Management Methods
+  // =============================================================================
+
+  async createController(params: CreateControllerRequest): Promise<ControllerResponse> {
+    return this.request<ControllerResponse>('/controllers/create', {
+      method: 'POST',
+      body: params
+    });
+  }
+
+  async getControllers(): Promise<ControllerResponse[]> {
+    return this.request<ControllerResponse[]>('/controllers');
+  }
+
+  async getController(id: string): Promise<ControllerResponse> {
+    return this.request<ControllerResponse>(`/controllers/${id}`);
+  }
+
+  async startController(id: string): Promise<{ success: boolean; message: string }> {
+    return this.request<{ success: boolean; message: string }>(`/controllers/${id}/start`, {
+      method: 'POST'
+    });
+  }
+
+  async stopController(id: string): Promise<{ success: boolean; message: string }> {
+    return this.request<{ success: boolean; message: string }>(`/controllers/${id}/stop`, {
+      method: 'POST'
+    });
+  }
+
+  async getControllerMetrics(id: string): Promise<ControllerMetrics> {
+    return this.request<ControllerMetrics>(`/controllers/${id}/metrics`);
+  }
+
+  async updateControllerConfig(id: string, config: ConfigurationObject): Promise<ControllerResponse> {
+    return this.request<ControllerResponse>(`/controllers/${id}/config`, {
+      method: 'PUT',
+      body: config
+    });
+  }
+
+  // =============================================================================
+  // Trading Operations Methods
+  // =============================================================================
+
+  async getExchanges(): Promise<ExchangeListResponse> {
+    return this.request<ExchangeListResponse>('/trading/exchanges');
+  }
+
+  async connectExchange(controllerId: string, params: ConnectExchangeRequest): Promise<TradingConnectionResponse> {
+    return this.request<TradingConnectionResponse>(`/trading/${controllerId}/connect`, {
+      method: 'POST',
+      body: params
+    });
+  }
+
+  async getMarketData(controllerId: string): Promise<MarketDataResponse> {
+    return this.request<MarketDataResponse>(`/trading/${controllerId}/market-data`);
+  }
+
+  async getAccountBalance(controllerId: string): Promise<Record<string, number>> {
+    return this.request<Record<string, number>>(`/trading/${controllerId}/balance`);
+  }
+
+  async getConnectionStatus(controllerId: string): Promise<{ connected: boolean; exchange: string; trading_pair: string }> {
+    return this.request<{ connected: boolean; exchange: string; trading_pair: string }>(`/trading/${controllerId}/connection-status`);
+  }
+
+  async executeSignal(params: ExecuteSignalRequest): Promise<SignalExecutionResponse> {
+    return this.request<SignalExecutionResponse>('/trading/execute-signal', {
+      method: 'POST',
+      body: params
+    });
+  }
+
+  // =============================================================================
+  // Bot Management Methods (Legacy)
+  // =============================================================================
+
+  async createBot(params: CreateBotRequest): Promise<BotResponse> {
+    return this.request<BotResponse>('/bots', {
+      method: 'POST',
+      body: params
+    });
+  }
+
+  async getBots(): Promise<BotResponse[]> {
+    return this.request<BotResponse[]>('/bots');
+  }
+
+  async getBot(id: string): Promise<BotResponse> {
+    return this.request<BotResponse>(`/bots/${id}`);
+  }
+
+  async getBotStatus(id: string): Promise<{ status: string; is_running: boolean }> {
+    return this.request<{ status: string; is_running: boolean }>(`/bots/${id}/status`);
+  }
+
+  // =============================================================================
+  // Pool Management Methods
+  // =============================================================================
+
+  async createPool(params: CreatePoolRequest): Promise<PoolResponse> {
+    return this.request<PoolResponse>('/pools/create', {
+      method: 'POST',
+      body: params
+    });
+  }
+
+  async getPools(): Promise<PoolResponse[]> {
+    return this.request<PoolResponse[]>('/pools');
+  }
+
+  async getPool(id: string): Promise<PoolResponse> {
+    return this.request<PoolResponse>(`/pools/${id}`);
+  }
+
+  // =============================================================================
+  // Hyperliquid Market Data Methods (Legacy)
+  // =============================================================================
+
+  async getHyperliquidOrderbook(pair: string): Promise<HyperliquidOrderbook> {
+    return this.request<HyperliquidOrderbook>(`/hyperliquid/orderbook/${pair}`);
+  }
+
+  async getHyperliquidSummary(pair: string): Promise<HyperliquidSummary> {
+    return this.request<HyperliquidSummary>(`/hyperliquid/summary/${pair}`);
+  }
+
+  // =============================================================================
+  // Utility Methods
+  // =============================================================================
+
+  /**
+   * Update client configuration
+   */
+  updateConfig(newConfig: Partial<MCPClientConfig>): void {
+    this.config = { ...this.config, ...newConfig };
+    
+    if (newConfig.headers) {
+      this.headers = { ...this.headers, ...newConfig.headers };
+    }
+    
+    if (newConfig.apiKey !== undefined) {
+      if (newConfig.apiKey) {
+        this.headers['Authorization'] = `Bearer ${newConfig.apiKey}`;
+      } else {
+        delete this.headers['Authorization'];
+      }
+    }
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): MCPClientConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Enable or disable logging
+   */
+  setLogging(enabled: boolean): void {
+    this.config.enableLogging = enabled;
+  }
+
+  /**
+   * Test connection to MCP server
+   */
+  async testConnection(): Promise<boolean> {
+    try {
+      await this.getHealth();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // =============================================================================
+  // MCP Tools Methods (Standardized Interface)
+  // =============================================================================
+
+  /**
+   * List available MCP tools
+   */
+  async listTools(): Promise<MCPToolsListResponse> {
+    const request: MCPRequest = {
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: 'tools/list'
+    };
+
+    const response = await this.request<MCPResponse>('/mcp', {
+      method: 'POST',
+      body: request
+    });
+
+    if (response.error) {
+      throw new MCPClientError(response.error.message, response.error.code, response.error.data);
+    }
+
+    return response.result as MCPToolsListResponse;
+  }
+
+  /**
+   * Call an MCP tool
+   */
+  async callTool(toolCall: MCPToolCallRequest): Promise<MCPToolCallResponse> {
+    const request: MCPRequest = {
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: 'tools/call',
+      params: toolCall
+    };
+
+    const response = await this.request<MCPResponse>('/mcp', {
+      method: 'POST',
+      body: request
+    });
+
+    if (response.error) {
+      throw new MCPClientError(response.error.message, response.error.code, response.error.data);
+    }
+
+    return response.result as MCPToolCallResponse;
+  }
+
+  /**
+   * Ping MCP server
+   */
+  async ping(): Promise<{ status: string; service?: string }> {
+    const request: MCPRequest = {
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method: 'ping'
+    };
+
+    const response = await this.request<MCPResponse>('/mcp', {
+      method: 'POST',
+      body: request
+    });
+
+    if (response.error) {
+      throw new MCPClientError(response.error.message, response.error.code, response.error.data);
+    }
+
+    return response.result;
+  }
+
+  // =============================================================================
+  // Dexscreener MCP Tools (Convenience Methods)
+  // =============================================================================
+
+  async getTrendingTokens(): Promise<MCPToolCallResponse> {
+    return this.callTool({ name: 'get_trending_tokens' });
+  }
+
+  async getLatestTokens(): Promise<MCPToolCallResponse> {
+    return this.callTool({ name: 'get_latest_tokens' });
+  }
+
+  async analyzeTrendingTokens(): Promise<MCPToolCallResponse> {
+    return this.callTool({ name: 'analyze_trending_tokens' });
+  }
+
+  async getDexscreenerContext(): Promise<MCPToolCallResponse> {
+    return this.callTool({ name: 'get_server_context' });
+  }
+
+  // =============================================================================
+  // Data Collector MCP Tools (Convenience Methods)
+  // =============================================================================
+
+  async getTokenPrice(params: {
+    token: string;
+    chain?: string;
+    quote?: string;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_token_price',
+      arguments: params
+    });
+  }
+
+  async getTokenVolume(params: {
+    token: string;
+    chain?: string;
+    interval?: string;
+    tokenFormat?: string;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_token_volume',
+      arguments: params
+    });
+  }
+
+  async getOrderbook(params: {
+    base: string;
+    quote?: string;
+    chain?: string;
+    depth?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_orderbook',
+      arguments: params
+    });
+  }
+
+  async getEnhancedOHLCV(params: {
+    token: string;
+    chain?: string;
+    interval?: string;
+    limit?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_enhanced_ohlcv',
+      arguments: params
+    });
+  }
+
+  async discoverTokens(params: {
+    chain?: string;
+    type?: string;
+    limit?: number;
+    includeVolume?: boolean;
+    sortBy?: string;
+    sortOrder?: string;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'discover_tokens',
+      arguments: params
+    });
+  }
+
+  async getTradingIntensity(params: {
+    token: string;
+    chain?: string;
+    interval?: string;
+    tokenFormat?: string;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_trading_intensity',
+      arguments: params
+    });
+  }
+
+  async resolveSymbol(params: {
+    symbol: string;
+    chain?: string;
+    type?: string;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'resolve_symbol',
+      arguments: params
+    });
+  }
+
+  async getPerformanceMetrics(params: {
+    chain?: string;
+    endpoint?: string;
+    samples?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_performance_metrics',
+      arguments: params
+    });
+  }
+
+  // =============================================================================
+  // RAG MCP Tools (Convenience Methods) - Knowledge & Decision Support
+  // =============================================================================
+
+  async searchKnowledgeBase(params: {
+    query: string;
+    limit?: number;
+    threshold?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'search_knowledge_base',
+      arguments: params
+    });
+  }
+
+  async retrieveContextualInformation(params: {
+    query: string;
+    sources?: Array<'concept' | 'history'>;
+    limit?: number;
+    threshold?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'retrieve_contextual_information',
+      arguments: params
+    });
+  }
+
+  async getHistoricalDecisions(params: {
+    query: string;
+    limit?: number;
+    threshold?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'get_historical_decisions',
+      arguments: params
+    });
+  }
+
+  async enrichMarketContext(params: {
+    topic: string;
+    includeHistory?: boolean;
+    includeConcepts?: boolean;
+    limit?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'enrich_market_context',
+      arguments: params
+    });
+  }
+
+  async comprehensiveSearch(params: {
+    query: string;
+    analysisDepth?: 'surface' | 'detailed' | 'comprehensive';
+    includeStatistics?: boolean;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'comprehensive_search',
+      arguments: params
+    });
+  }
+
+  async checkKnowledgeBaseStatus(params?: {
+    includeLayerStats?: boolean;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'check_knowledge_base_status',
+      arguments: params || {}
+    });
+  }
+
+  // =============================================================================
+  // APY Strategy MCP Tools (Convenience Methods) - DeFi Yield Optimization
+  // =============================================================================
+
+  async getApyHistory(params: {
+    protocol: string;
+    chain: string;
+    pool?: string;
+    timeframe?: '7d' | '30d' | '90d' | '180d' | '1y';
+    includeRiskMetrics?: boolean;
+    includeStatistics?: boolean;
+    minTvl?: number;
+    maxRiskScore?: number;
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'getApyHistory',
+      arguments: params
+    });
+  }
+
+  async findYieldOpportunities(params: {
+    chains?: string[];
+    minApy?: number;
+    maxRisk?: number;
+    minTvl?: number;
+    protocols?: string[];
+    assets?: string[];
+    includeArbitrage?: boolean;
+    riskTolerance?: 'conservative' | 'moderate' | 'aggressive';
+    sortBy?: 'apy' | 'risk_adjusted_return' | 'tvl' | 'risk_score';
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'findYieldOpportunities',
+      arguments: params
+    });
+  }
+
+  async analyzeArbitrageOpportunities(params: {
+    sourceChain: string;
+    targetChain: string;
+    token: string;
+    amount?: number;
+    includeGasCosts?: boolean;
+    slippageTolerance?: number;
+    bridgeProtocols?: string[];
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'analyzeArbitrageOpportunities',
+      arguments: params
+    });
+  }
+
+  async backtestStrategy(params: {
+    strategy: 'yield_farming' | 'arbitrage' | 'optimization' | 'balanced';
+    protocols?: string[];
+    chains?: string[];
+    startDate: string;
+    endDate: string;
+    initialAmount: number;
+    rebalanceFrequency?: 'daily' | 'weekly' | 'monthly' | 'quarterly';
+    riskTolerance?: 'conservative' | 'moderate' | 'aggressive';
+    includeTransactionCosts?: boolean;
+    optimizationMethod?: 'max_sharpe' | 'risk_parity' | 'mean_variance';
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'backtestStrategy',
+      arguments: params
+    });
+  }
+
+  async calculatePortfolioRisk(params: {
+    positions: Array<{
+      protocol: string;
+      chain?: string;
+      asset: string;
+      amount: number;
+      currentApy?: number;
+    }>;
+    riskMetrics?: ('var' | 'correlation' | 'concentration' | 'stress_test')[];
+    confidenceLevel?: 90 | 95 | 99;
+    timeHorizon?: number;
+    stressScenarios?: string[];
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'calculatePortfolioRisk',
+      arguments: params
+    });
+  }
+
+  async optimizeYieldAllocation(params: {
+    amount: number;
+    riskTolerance: 'conservative' | 'moderate' | 'aggressive';
+    optimizationMethod: 'max_sharpe' | 'risk_parity' | 'mean_variance' | 'min_variance';
+    constraints?: {
+      maxProtocolAllocation?: number;
+      maxChainAllocation?: number;
+      maxRiskScore?: number;
+      minYield?: number;
+    };
+    includeProtocols?: string[];
+    excludeProtocols?: string[];
+    targetChains?: string[];
+    rebalanceFrequency?: 'never' | 'daily' | 'weekly' | 'monthly';
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'optimizeYieldAllocation',
+      arguments: params
+    });
+  }
+
+  async assessProtocolRisk(params: {
+    protocol: string;
+    chain?: string;
+    includeHistoricalEvents?: boolean;
+    riskCategories?: ('smart_contract' | 'economic' | 'governance' | 'liquidity' | 'oracle')[];
+    depth?: 'basic' | 'detailed' | 'comprehensive';
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'assessProtocolRisk',
+      arguments: params
+    });
+  }
+
+  async trackYieldPerformance(params: {
+    portfolioId: string;
+    timeframe?: '1d' | '7d' | '30d' | '90d' | '1y' | 'all';
+    includeBenchmarks?: boolean;
+    benchmarks?: string[];
+    attributionAnalysis?: boolean;
+    includeRealTimeData?: boolean;
+    alertThresholds?: {
+      minYield?: number;
+      maxDrawdown?: number;
+      riskScoreChange?: number;
+    };
+    granularity?: 'hourly' | 'daily' | 'weekly';
+  }): Promise<MCPToolCallResponse> {
+    return this.callTool({
+      name: 'trackYieldPerformance',
+      arguments: params
+    });
+  }
+}