language-operator 0.0.1 → 0.1.31

data/lib/language_operator/client/base.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'ruby_llm'
+require 'ruby_llm/mcp'
+require 'json'
+require_relative 'config'
+require_relative 'cost_calculator'
+require_relative 'mcp_connector'
+require_relative '../logger'
+require_relative '../loggable'
+require_relative '../retryable'
+require_relative '../agent/instrumentation'
+
+module LanguageOperator
+  module Client
+    # Core MCP client that connects to multiple servers and manages LLM chat
+    #
+    # This class handles all the backend logic for connecting to MCP servers,
+    # configuring the LLM, and managing chat sessions. It's designed to be
+    # UI-agnostic and reusable across different interfaces (CLI, web, headless).
+    #
+    # @example Basic usage
+    #   config = Config.load('config.yaml')
+    #   client = Base.new(config)
+    #   client.connect!
+    #   response = client.send_message("What tools are available?")
+    #
+    # @example Streaming responses
+    #   client.stream_message("Search for Ruby news") do |chunk|
+    #     print chunk
+    #   end
+    class Base
+      include LanguageOperator::Loggable
+      include LanguageOperator::Retryable
+      include LanguageOperator::Agent::Instrumentation
+      include CostCalculator
+      include MCPConnector
+
+      attr_reader :config, :clients, :chat
+
+      # Initialize the client with configuration
+      #
+      # @param config [Hash, String] Configuration hash or path to YAML file
+      def initialize(config)
+        @config = config.is_a?(String) ? Config.load(config) : config
+        @clients = []
+        @chat = nil
+        @debug = @config['debug'] || false
+
+        logger.debug('Client initialized',
+                     debug: @debug,
+                     llm_provider: @config.dig('llm', 'provider'),
+                     llm_model: @config.dig('llm', 'model'))
+      end
+
+      # Connect to all enabled MCP servers and configure LLM
+      #
+      # @return [Hash] Connection results with status and tool counts
+      # @raise [RuntimeError] If LLM configuration fails
+      def connect!
+        configure_llm
+        connect_mcp_servers
+      end
+
+      # Send a message and get the full response
+      #
+      # @param message [String] User message
+      # @return [String] Assistant response
+      # @raise [StandardError] If message fails
+      def send_message(message)
+        raise 'Not connected. Call #connect! first.' unless @chat
+
+        model = @config.dig('llm', 'model')
+        provider = @config.dig('llm', 'provider')
+
+        with_span('agent.llm.request', attributes: {
+                    'llm.model' => model,
+                    'llm.provider' => provider,
+                    'llm.message_count' => @chat.respond_to?(:messages) ? @chat.messages.length : nil
+                  }) do |span|
+          result = @chat.ask(message)
+
+          # Add token usage and cost attributes if available
+          if result.respond_to?(:input_tokens)
+            input_tokens = result.input_tokens || 0
+            output_tokens = result.output_tokens || 0
+            cost = calculate_cost(model, input_tokens, output_tokens)
+
+            span.set_attribute('llm.input_tokens', input_tokens)
+            span.set_attribute('llm.output_tokens', output_tokens)
+            span.set_attribute('llm.cost_usd', cost.round(6)) if cost
+          end
+
+          result
+        end
+      end
+
+      # Stream a message and yield each chunk
+      #
+      # @param message [String] User message
+      # @yield [String] Each chunk of the response
+      # @raise [StandardError] If streaming fails
+      def stream_message(message, &block)
+        raise 'Not connected. Call #connect! first.' unless @chat
+
+        # NOTE: RubyLLM may not support streaming yet, so we'll call ask and yield the full response
+        response = @chat.ask(message)
+
+        # Convert response to string if it's a RubyLLM::Message object
+        response_text = response.respond_to?(:content) ? response.content : response.to_s
+
+        block.call(response_text) if block_given?
+        response_text
+      end
+
+      # Get all available tools from connected servers
+      #
+      # @return [Array] Array of tool objects
+      def tools
+        @clients.flat_map(&:tools)
+      end
+
+      # Get information about connected servers
+      #
+      # @return [Array<Hash>] Server information (name, url, tool_count)
+      def servers_info
+        @clients.map do |client|
+          {
+            name: client.name,
+            tool_count: client.tools.length,
+            tools: client.tools.map(&:name)
+          }
+        end
+      end
+
+      # Clear chat history while keeping MCP connections
+      #
+      # @return [void]
+      def clear_history!
+        llm_config = @config['llm']
+        chat_params = build_chat_params(llm_config)
+        @chat = RubyLLM.chat(**chat_params)
+
+        all_tools = tools
+        @chat.with_tools(*all_tools) unless all_tools.empty?
+      end
+
+      # Check if the client is connected
+      #
+      # @return [Boolean] True if connected to at least one server
+      def connected?
+        !@clients.empty? && !@chat.nil?
+      end
+
+      # Get debug mode status
+      #
+      # @return [Boolean] True if debug mode is enabled
+      def debug?
+        @debug
+      end
+
+      private
+
+      def logger_component
+        'Client'
+      end
+
+      # Configure RubyLLM with provider settings
+      #
+      # @raise [RuntimeError] If provider is unknown
+      def configure_llm
+        llm_config = @config['llm']
+        provider = llm_config['provider']
+        model = llm_config['model']
+        timeout = llm_config['timeout'] || 300
+
+        logger.info('Configuring LLM',
+                    provider: provider,
+                    model: model,
+                    timeout: timeout)
+
+        logger.debug('Using custom endpoint', endpoint: llm_config['endpoint']) if provider == 'openai_compatible' && llm_config['endpoint']
+
+        RubyLLM.configure do |config|
+          case provider
+          when 'openai'
+            config.openai_api_key = llm_config['api_key']
+          when 'openai_compatible'
+            config.openai_api_key = llm_config['api_key'] || 'not-needed'
+            config.openai_api_base = llm_config['endpoint']
+          when 'anthropic'
+            config.anthropic_api_key = llm_config['api_key']
+          else
+            logger.error('Unknown LLM provider', provider: provider)
+            raise "Unknown provider: #{provider}"
+          end
+
+          # Set timeout for LLM inference (default 300 seconds for slow local models)
+          # RubyLLM uses request_timeout to control HTTP request timeouts
+          config.request_timeout = timeout if config.respond_to?(:request_timeout=)
+        end
+
+        # Configure MCP timeout separately (MCP has its own timeout setting)
+        # MCP request_timeout is in milliseconds, default is 300000ms (5 minutes)
+        RubyLLM::MCP.configure do |config|
+          mcp_timeout_ms = timeout * 1000
+          config.request_timeout = mcp_timeout_ms if config.respond_to?(:request_timeout=)
+        end
+
+        logger.info('LLM configuration complete')
+      end
+    end
+  end
+end

data/lib/language_operator/client/config.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module LanguageOperator
+  module Client
+    # Configuration management for Langop MCP Client
+    #
+    # Handles loading configuration from YAML files or environment variables,
+    # with automatic provider detection and sensible defaults.
+    #
+    # @example Load from YAML file
+    #   config = Config.load('/path/to/config.yaml')
+    #
+    # @example Load from environment variables
+    #   config = Config.from_env
+    #
+    # @example Load with fallback
+    #   config = Config.load_with_fallback('/path/to/config.yaml')
+    class Config
+      # Load configuration from a YAML file
+      #
+      # @param path [String] Path to YAML configuration file
+      # @return [Hash] Configuration hash
+      # @raise [Errno::ENOENT] If file doesn't exist
+      def self.load(path)
+        YAML.load_file(path)
+      end
+
+      # Load configuration from environment variables
+      #
+      # @return [Hash] Configuration hash built from ENV
+      def self.from_env
+        {
+          'llm' => {
+            'provider' => detect_provider_from_env,
+            'model' => ENV.fetch('LLM_MODEL') { default_model_from_env },
+            'endpoint' => parse_model_endpoint_from_env,
+            'api_key' => ENV.fetch('OPENAI_API_KEY') { ENV.fetch('ANTHROPIC_API_KEY', 'dummy-key-for-local-proxy') }
+          },
+          'mcp_servers' => parse_mcp_servers_from_env,
+          'debug' => ENV['DEBUG'] == 'true'
+        }
+      end
+
+      # Parse model endpoint from environment variable
+      #
+      # Supports both MODEL_ENDPOINTS (comma-separated, uses first) and OPENAI_ENDPOINT
+      #
+      # @return [String, nil] Model endpoint URL
+      def self.parse_model_endpoint_from_env
+        # Support MODEL_ENDPOINTS (operator sets this)
+        endpoints_env = ENV.fetch('MODEL_ENDPOINTS', nil)
+        if endpoints_env && !endpoints_env.empty?
+          # Take the first endpoint from comma-separated list
+          endpoints_env.split(',').first.strip
+        else
+          # Fallback to legacy OPENAI_ENDPOINT
+          ENV.fetch('OPENAI_ENDPOINT', nil)
+        end
+      end
+
+      # Load configuration with automatic fallback to environment variables
+      #
+      # @param path [String] Path to YAML configuration file
+      # @return [Hash] Configuration hash
+      def self.load_with_fallback(path)
+        return from_env unless File.exist?(path)
+
+        load(path)
+      rescue StandardError => e
+        warn "⚠️  Error loading config from #{path}: #{e.message}"
+        warn 'Using environment variable fallback mode...'
+        from_env
+      end
+
+      # Detect LLM provider from environment variables
+      #
+      # @return [String] Provider name (openai_compatible, openai, or anthropic)
+      # @raise [RuntimeError] If no API key or endpoint is found
+      def self.detect_provider_from_env
+        if ENV['OPENAI_ENDPOINT'] || ENV['MODEL_ENDPOINTS']
+          'openai_compatible'
+        elsif ENV['OPENAI_API_KEY']
+          'openai'
+        elsif ENV['ANTHROPIC_API_KEY']
+          'anthropic'
+        else
+          raise 'No API key or endpoint found. Set OPENAI_ENDPOINT or MODEL_ENDPOINTS for local LLM, ' \
+                'or OPENAI_API_KEY/ANTHROPIC_API_KEY for cloud providers.'
+        end
+      end
+
+      # Get default model for detected provider
+      #
+      # @return [String] Default model name
+      def self.default_model_from_env
+        {
+          'openai' => 'gpt-4',
+          'openai_compatible' => 'gpt-3.5-turbo',
+          'anthropic' => 'claude-3-5-sonnet-20241022'
+        }[detect_provider_from_env]
+      end
+
+      # Parse MCP servers from environment variables
+      #
+      # Supports MCP_SERVERS env var as comma-separated URLs or single MCP_URL
+      #
+      # @return [Array<Hash>] Array of MCP server configurations
+      def self.parse_mcp_servers_from_env
+        # Support both MCP_SERVERS (comma-separated) and legacy MCP_URL
+        servers_env = ENV.fetch('MCP_SERVERS', nil)
+        if servers_env && !servers_env.empty?
+          # Parse comma-separated URLs
+          servers_env.split(',').map.with_index do |url, index|
+            {
+              'name' => "default-tools-#{index}",
+              'url' => url.strip,
+              'transport' => 'streamable',
+              'enabled' => true
+            }
+          end
+        elsif ENV['MCP_URL']
+          [{
+            'name' => 'default-tools',
+            'url' => ENV['MCP_URL'],
+            'transport' => 'streamable',
+            'enabled' => true
+          }]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/client/cost_calculator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Client
+    # Calculates LLM API costs based on token usage and model pricing
+    module CostCalculator
+      # Model pricing per 1M tokens (input, output) in USD
+      MODEL_PRICING = {
+        # OpenAI models
+        'gpt-4' => [30.0, 60.0],
+        'gpt-4-turbo' => [10.0, 30.0],
+        'gpt-4o' => [5.0, 15.0],
+        'gpt-3.5-turbo' => [0.5, 1.5],
+        # Anthropic models
+        'claude-3-5-sonnet-20241022' => [3.0, 15.0],
+        'claude-3-opus-20240229' => [15.0, 75.0],
+        'claude-3-sonnet-20240229' => [3.0, 15.0],
+        'claude-3-haiku-20240307' => [0.25, 1.25]
+      }.freeze
+
+      # Calculate cost based on model and token usage
+      #
+      # @param model [String] Model name
+      # @param input_tokens [Integer] Number of input tokens
+      # @param output_tokens [Integer] Number of output tokens
+      # @return [Float, nil] Cost in USD, or nil if model pricing not found
+      def calculate_cost(model, input_tokens, output_tokens)
+        pricing = MODEL_PRICING[model]
+        return nil unless pricing
+
+        input_cost = (input_tokens / 1_000_000.0) * pricing[0]
+        output_cost = (output_tokens / 1_000_000.0) * pricing[1]
+        input_cost + output_cost
+      end
+    end
+  end
+end

data/lib/language_operator/client/mcp_connector.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module LanguageOperator
+  module Client
+    # Handles MCP server connection logic
+    module MCPConnector
+      private
+
+      # Connect to all enabled MCP servers
+      #
+      # @return [void]
+      def connect_mcp_servers
+        enabled_servers = @config['mcp_servers'].select { |s| s['enabled'] }
+
+        all_tools = []
+
+        if enabled_servers.empty?
+          logger.info('No MCP servers configured, agent will run without tools')
+        else
+          logger.info('Connecting to MCP servers', count: enabled_servers.length)
+
+          enabled_servers.each do |server_config|
+            client = connect_with_retry(server_config)
+            next unless client
+
+            @clients << client
+            tool_count = client.tools.length
+            all_tools.concat(client.tools)
+
+            logger.info('MCP server connected',
+                        server: server_config['name'],
+                        tool_count: tool_count,
+                        tools: client.tools.map(&:name))
+          rescue StandardError => e
+            logger.error('Error connecting to MCP server',
+                         server: server_config['name'],
+                         error: e.message)
+            if @debug
+              logger.debug('Connection error backtrace',
+                           server: server_config['name'],
+                           backtrace: e.backtrace.join("\n"))
+            end
+          end
+
+          logger.info('MCP connection summary',
+                      connected_servers: @clients.length,
+                      total_tools: all_tools.length)
+        end
+
+        # Create chat with all collected tools (even if empty)
+        llm_config = @config['llm']
+        chat_params = build_chat_params(llm_config)
+        @chat = RubyLLM.chat(**chat_params)
+
+        @chat.with_tools(*all_tools) unless all_tools.empty?
+
+        logger.info('Chat session initialized', with_tools: !all_tools.empty?)
+      end
+
+      # Connect to MCP server with exponential backoff retry logic
+      #
+      # @param server_config [Hash] Server configuration
+      # @return [RubyLLM::MCP::Client, nil] Client if successful, nil if all retries failed
+      def connect_with_retry(server_config)
+        logger.debug('Attempting to connect to MCP server',
+                     server: server_config['name'],
+                     transport: server_config['transport'],
+                     url: server_config['url'])
+
+        with_retry_or_nil(
+          max_attempts: 4, # 1 initial attempt + 3 retries
+          base_delay: 1.0,
+          max_delay: 30.0,
+          on_retry: lambda { |error, attempt, delay|
+            logger.warn('MCP server connection failed, retrying',
+                        server: server_config['name'],
+                        attempt: attempt,
+                        max_attempts: 4,
+                        error: error.message,
+                        retry_delay: delay)
+          },
+          on_failure: lambda { |error, attempts|
+            logger.error('MCP server connection failed after all retries',
+                         server: server_config['name'],
+                         attempts: attempts,
+                         error: error.message)
+            if @debug
+              logger.debug('Final connection error backtrace',
+                           server: server_config['name'],
+                           backtrace: error.backtrace.join("\n"))
+            end
+          }
+        ) do
+          client = RubyLLM::MCP.client(
+            name: server_config['name'],
+            transport_type: server_config['transport'].to_sym,
+            config: {
+              url: server_config['url']
+            }
+          )
+
+          logger.info('Successfully connected to MCP server',
+                      server: server_config['name'])
+          client
+        end
+      end
+
+      # Build chat parameters based on LLM config
+      #
+      # @param llm_config [Hash] LLM configuration
+      # @return [Hash] Chat parameters for RubyLLM.chat
+      def build_chat_params(llm_config)
+        chat_params = { model: llm_config['model'] }
+        if llm_config['provider'] == 'openai_compatible'
+          chat_params[:provider] = :openai
+          chat_params[:assume_model_exists] = true
+        end
+
+        chat_params
+      end
+    end
+  end
+end

data/lib/language_operator/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'client/base'
+require_relative 'client/config'
+
+module LanguageOperator
+  # MCP Client for connecting to and using MCP servers
+  #
+  # Provides a high-level interface for connecting to MCP servers,
+  # querying available tools, and sending messages to language models
+  # with tool calling capabilities.
+  #
+  # @example Basic usage
+  #   client = LanguageOperator::Client::Base.new(config)
+  #   client.connect!
+  #   response = client.send_message("What can you do?")
+  module Client
+  end
+end

data/lib/language_operator/config/cluster_config.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module LanguageOperator
+  module Config
+    # Manages cluster configuration in ~/.aictl/config.yaml
+    class ClusterConfig
+      CONFIG_DIR = File.expand_path('~/.aictl')
+      CONFIG_PATH = File.join(CONFIG_DIR, 'config.yaml')
+
+      class << self
+        def load
+          return default_config unless File.exist?(CONFIG_PATH)
+
+          YAML.load_file(CONFIG_PATH) || default_config
+        rescue StandardError => e
+          warn "Warning: Failed to load config from #{CONFIG_PATH}: #{e.message}"
+          default_config
+        end
+
+        def save(config)
+          FileUtils.mkdir_p(CONFIG_DIR)
+          File.write(CONFIG_PATH, YAML.dump(config))
+        end
+
+        def current_cluster
+          config = load
+          config['current-cluster']
+        end
+
+        def set_current_cluster(name)
+          config = load
+          raise ArgumentError, "Cluster '#{name}' does not exist" unless cluster_exists?(name)
+
+          config['current-cluster'] = name
+          save(config)
+        end
+
+        def add_cluster(name, namespace, kubeconfig, context)
+          config = load
+          config['clusters'] ||= []
+
+          # Remove existing cluster with same name
+          config['clusters'].reject! { |c| c['name'] == name }
+
+          # Add new cluster
+          config['clusters'] << {
+            'name' => name,
+            'namespace' => namespace,
+            'kubeconfig' => kubeconfig,
+            'context' => context,
+            'created' => Time.now.utc.iso8601
+          }
+
+          save(config)
+        end
+
+        def remove_cluster(name)
+          config = load
+          config['clusters']&.reject! { |c| c['name'] == name }
+
+          # Clear current-cluster if it was the removed one
+          config['current-cluster'] = nil if config['current-cluster'] == name
+
+          save(config)
+        end
+
+        def get_cluster(name)
+          config = load
+          cluster = config['clusters']&.find { |c| c['name'] == name }
+          # Convert string keys to symbol keys for easier access
+          cluster&.transform_keys(&:to_sym)
+        end
+
+        def list_clusters
+          config = load
+          clusters = config['clusters'] || []
+          # Convert string keys to symbol keys for easier access
+          clusters.map { |c| c.transform_keys(&:to_sym) }
+        end
+
+        def cluster_exists?(name)
+          !get_cluster(name).nil?
+        end
+
+        private
+
+        def default_config
+          {
+            'apiVersion' => 'aictl.langop.io/v1',
+            'kind' => 'Config',
+            'current-cluster' => nil,
+            'clusters' => []
+          }
+        end
+      end
+    end
+  end
+end

data/lib/language_operator/config/tool_patterns.yaml

@@ -0,0 +1,57 @@
+# Tool Registry Mapping
+# Maps tool keywords to container images and default configurations
+
+# Built-in tools (developed in this project)
+web:
+  image: ghcr.io/language-operator/web-tool:latest
+  displayName: Web Tool
+  description: Search the web and fetch web pages using DuckDuckGo
+  deploymentMode: service
+  port: 8080
+  type: mcp
+  egress:
+    - description: Allow HTTPS to DuckDuckGo
+      dns:
+        - "*.duckduckgo.com"
+        - "duckduckgo.com"
+      ports:
+        - port: 443
+          protocol: TCP
+    - description: Allow HTTPS to any web destination
+      dns:
+        - "*"
+      ports:
+        - port: 443
+          protocol: TCP
+        - port: 80
+          protocol: TCP
+
+email:
+  image: ghcr.io/language-operator/email-tool:latest
+  displayName: Email Tool
+  description: Send and receive emails via SMTP/IMAP
+  deploymentMode: service
+  port: 8080
+  type: mcp
+  authRequired: true
+  egress:
+    - description: Allow SMTP/IMAP connections
+      dns:
+        - "*"
+      ports:
+        - port: 587
+          protocol: TCP
+        - port: 465
+          protocol: TCP
+        - port: 993
+          protocol: TCP
+
+# Aliases for convenience
+web-search:
+  alias: web
+
+web-fetch:
+  alias: web
+
+http:
+  alias: web