mcp_on_ruby 0.3.0 → 2.0.0

data/lib/ruby_mcp/client.rb

@@ -1,43 +0,0 @@
-# lib/ruby_mcp/client.rb
-# frozen_string_literal: true
-
-module RubyMCP
-  class Client
-    attr_reader :storage
-
-    def initialize(storage)
-      @storage = storage
-    end
-
-    def create_context(messages = [], metadata = {})
-      context = RubyMCP::Models::Context.new(messages: messages, metadata: metadata)
-      storage.create_context(context)
-    end
-
-    def list_contexts(limit: 50, offset: 0)
-      storage.list_contexts(limit: limit, offset: offset)
-    end
-
-    def get_context(context_id)
-      storage.get_context(context_id)
-    end
-
-    def delete_context(context_id)
-      storage.delete_context(context_id)
-    end
-
-    def add_message(context_id, role, content, metadata: {})
-      message = RubyMCP::Models::Message.new(role: role, content: content, metadata: metadata)
-      storage.add_message(context_id, message)
-    end
-
-    def add_content(context_id, content_data, content_id = nil)
-      content_id ||= "cnt_#{SecureRandom.hex(10)}"
-      storage.add_content(context_id, content_id, content_data)
-    end
-
-    def get_content(context_id, content_id)
-      storage.get_content(context_id, content_id)
-    end
-  end
-end

data/lib/ruby_mcp/configuration.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  class Configuration
-    attr_accessor :providers, :storage, :server_port, :server_host,
-                  :auth_required, :jwt_secret, :token_expiry, :max_contexts,
-                  :redis, :active_record
-
-    def initialize
-      @providers = {}
-      @storage = :memory
-      @server_port = 3000
-      @server_host = '0.0.0.0'
-      @auth_required = false
-      @jwt_secret = nil
-      @token_expiry = 3600 # 1 hour
-      @max_contexts = 1000
-      @redis = {}         # Default empty Redis config
-      @active_record = {} # Default empty ActiveRecord config
-    end
-
-    def storage_config
-      case @storage
-      when :redis
-        {
-          type: :redis,
-          connection: redis_connection_config,
-          namespace: @redis[:namespace] || 'ruby_mcp',
-          ttl: @redis[:ttl] || 86_400
-        }
-      when :active_record
-        {
-          type: :active_record,
-          connection: @active_record[:connection],
-          table_prefix: @active_record[:table_prefix] || 'mcp_'
-        }
-      else
-        { type: @storage }
-      end
-    end
-
-    def storage_instance
-      @storage_instance ||= case @storage
-                            when :memory
-                              RubyMCP::Storage::Memory.new
-                            when :redis
-                              begin
-                                require 'redis'
-                                require_relative 'storage/redis'
-                                RubyMCP::Storage::Redis.new(storage_config)
-                              rescue LoadError
-                                raise RubyMCP::Errors::ConfigurationError,
-                                      "Redis storage requires the redis gem. Add it to your Gemfile with:
-                                      gem 'redis', '~> 5.0'"
-                              end
-                            when :active_record
-                              begin
-                                require 'active_record'
-                                require_relative 'storage/active_record'
-                                RubyMCP::Storage::ActiveRecord.new(storage_config)
-                              rescue LoadError
-                                raise RubyMCP::Errors::ConfigurationError,
-                                      "ActiveRecord storage requires the activerecord gem. Add it to your Gemfile with:
-                                      gem 'activerecord', '~> 6.0'"
-                              end
-                            else
-                              unless @storage.is_a?(RubyMCP::Storage::Base)
-                                raise RubyMCP::Errors::ConfigurationError, "Unknown storage type: #{@storage}"
-                              end
-
-                              @storage # Allow custom storage instance
-                            end
-    end
-
-    private
-
-    def redis_connection_config
-      if @redis[:url]
-        { url: @redis[:url] }
-      else
-        {
-          host: @redis[:host] || 'localhost',
-          port: @redis[:port] || 6379,
-          db: @redis[:db] || 0,
-          password: @redis[:password]
-        }.compact
-      end
-    end
-  end
-end

data/lib/ruby_mcp/errors.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Errors
-    class Error < StandardError; end
-
-    class ConfigurationError < Error; end
-    class AuthenticationError < Error; end
-    class ValidationError < Error; end
-    class ProviderError < Error; end
-    class ContextError < Error; end
-    class EngineError < Error; end
-    class MessageError < Error; end
-    class ContentError < Error; end
-    class ServerError < Error; end
-  end
-end

data/lib/ruby_mcp/models/context.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-module RubyMCP
-  module Models
-    class Context
-      attr_reader :id, :messages, :content_map, :created_at, :updated_at
-      attr_accessor :metadata
-
-      def initialize(id: nil, messages: [], metadata: {})
-        @id = id || "ctx_#{SecureRandom.hex(10)}"
-        @messages = messages || []
-        @content_map = {}
-        @metadata = metadata || {}
-        @created_at = Time.now.utc
-        @updated_at = @created_at
-      end
-
-      def add_message(message)
-        @messages << message
-        @updated_at = Time.now.utc
-        message
-      end
-
-      def add_content(content_id, content_data)
-        @content_map[content_id] = content_data
-        @updated_at = Time.now.utc
-        content_id
-      end
-
-      def get_content(content_id)
-        @content_map[content_id]
-      end
-
-      def to_h
-        {
-          id: @id,
-          messages: @messages.map(&:to_h),
-          content_map: @content_map,
-          created_at: @created_at.iso8601,
-          updated_at: @updated_at.iso8601,
-          metadata: @metadata
-        }
-      end
-
-      def estimated_token_count
-        @messages.sum(&:estimated_token_count)
-      end
-    end
-  end
-end

data/lib/ruby_mcp/models/engine.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Models
-    class Engine
-      attr_reader :id, :provider, :model, :capabilities, :config
-
-      def initialize(id:, provider:, model:, capabilities: [], config: {})
-        @id = id
-        @provider = provider
-        @model = model
-        @capabilities = capabilities
-        @config = config
-      end
-
-      def to_h
-        {
-          id: @id,
-          provider: @provider,
-          model: @model,
-          capabilities: @capabilities,
-          config: @config
-        }
-      end
-
-      def supports?(capability)
-        @capabilities.include?(capability.to_s)
-      end
-    end
-  end
-end

data/lib/ruby_mcp/models/message.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-module RubyMCP
-  module Models
-    class Message
-      VALID_ROLES = %w[user assistant system tool].freeze
-
-      attr_reader :id, :role, :content, :created_at
-      attr_accessor :metadata
-
-      def initialize(role:, content:, id: nil, metadata: {})
-        @id = id || "msg_#{SecureRandom.hex(10)}"
-
-        unless VALID_ROLES.include?(role)
-          raise RubyMCP::Errors::ValidationError, "Invalid role: #{role}. Must be one of: #{VALID_ROLES.join(', ')}"
-        end
-
-        @role = role
-        @content = content
-        @created_at = Time.now.utc
-        @metadata = metadata || {}
-      end
-
-      def to_h
-        {
-          id: @id,
-          role: @role,
-          content: @content,
-          created_at: @created_at.iso8601,
-          metadata: @metadata
-        }
-      end
-
-      def content_type
-        return 'array' if @content.is_a?(Array)
-
-        'text'
-      end
-
-      def estimated_token_count
-        # Very basic estimation, would need to be improved with a real tokenizer
-        if @content.is_a?(String)
-          @content.split(/\s+/).size
-        elsif @content.is_a?(Array)
-          @content.sum do |part|
-            if part.is_a?(String) || part[:text]
-              (part.is_a?(String) ? part : part[:text]).split(/\s+/).size
-            else
-              10 # Arbitrary count for non-text content
-            end
-          end
-        else
-          10 # Default for unknown content format
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/providers/anthropic.rb

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Providers
-    class Anthropic < Base
-      MODELS = [
-        {
-          id: 'claude-3-opus-20240229',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-3-sonnet-20240229',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-3-haiku-20240307',
-          capabilities: %w[text-generation streaming tool-calls]
-        },
-        {
-          id: 'claude-2.1',
-          capabilities: %w[text-generation streaming]
-        },
-        {
-          id: 'claude-2.0',
-          capabilities: %w[text-generation streaming]
-        },
-        {
-          id: 'claude-instant-1.2',
-          capabilities: %w[text-generation streaming]
-        }
-      ].freeze
-
-      def list_engines
-        # Anthropic doesn't have an endpoint to list models, so we use a static list
-        MODELS.map do |model_info|
-          RubyMCP::Models::Engine.new(
-            id: "anthropic/#{model_info[:id]}",
-            provider: 'anthropic',
-            model: model_info[:id],
-            capabilities: model_info[:capabilities]
-          )
-        end
-      end
-
-      def generate(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens] || 4096,
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          stop_sequences: options[:stop]
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        headers = {
-          'Anthropic-Version' => '2023-06-01',
-          'Content-Type' => 'application/json'
-        }
-
-        response = create_client.post('messages') do |req|
-          req.headers.merge!(headers)
-          req.body = payload.to_json
-        end
-
-        unless response.success?
-          raise RubyMCP::Errors::ProviderError,
-                "Anthropic generation failed: #{response.body['error']&.dig('message') || response.status}"
-        end
-
-        content = response.body['content']&.first&.dig('text')
-        tool_calls = nil
-
-        # Handle tool calls
-        if response.body['tool_calls']
-          tool_calls = response.body['tool_calls'].map do |tc|
-            {
-              id: tc['id'],
-              type: 'function',
-              function: {
-                name: tc['name'],
-                arguments: tc['input']
-              }
-            }
-          end
-        end
-
-        result = {
-          provider: 'anthropic',
-          model: options[:model],
-          created_at: Time.now.utc.iso8601
-        }
-
-        if tool_calls
-          result[:tool_calls] = tool_calls
-        else
-          result[:content] = content
-        end
-
-        result
-      end
-
-      def generate_stream(context, options = {})
-        messages = format_messages(context)
-
-        payload = {
-          model: options[:model],
-          messages: messages,
-          max_tokens: options[:max_tokens] || 4096,
-          temperature: options[:temperature],
-          top_p: options[:top_p],
-          stop_sequences: options[:stop],
-          stream: true
-        }.compact
-
-        if options[:tools]
-          payload[:tools] = options[:tools]
-          payload[:tool_choice] = options[:tool_choice] || 'auto'
-        end
-
-        headers = {
-          'Anthropic-Version' => '2023-06-01',
-          'Content-Type' => 'application/json'
-        }
-
-        conn = create_client
-
-        # Update the client to handle streaming
-        conn.options.timeout = 120 # Longer timeout for streaming
-
-        generation_id = SecureRandom.uuid
-        content_buffer = ''
-        current_tool_calls = []
-
-        # Initial event
-        yield({
-          id: generation_id,
-          event: 'generation.start',
-          created_at: Time.now.utc.iso8601
-        })
-
-        begin
-          conn.post('messages') do |req|
-            req.headers.merge!(headers)
-            req.body = payload.to_json
-            req.options.on_data = proc do |chunk, _size, _total|
-              next if chunk.strip.empty?
-
-              # Process each SSE event
-              chunk.split('data: ').each do |data|
-                next if data.strip.empty?
-
-                begin
-                  json = JSON.parse(data.strip)
-
-                  case json['type']
-                  when 'content_block_delta'
-                    delta = json['delta']['text']
-                    content_buffer += delta
-
-                    # Send content update
-                    yield({
-                      id: generation_id,
-                      event: 'generation.content',
-                      created_at: Time.now.utc.iso8601,
-                      content: delta
-                    })
-                  when 'tool_call'
-                    tool_call = {
-                      'id' => json['id'],
-                      'type' => 'function',
-                      'function' => {
-                        'name' => json['name'],
-                        'arguments' => json['input']
-                      }
-                    }
-
-                    current_tool_calls << tool_call
-
-                    # Send tool call update
-                    yield({
-                      id: generation_id,
-                      event: 'generation.tool_call',
-                      created_at: Time.now.utc.iso8601,
-                      tool_calls: current_tool_calls
-                    })
-                  when 'message_stop'
-                    # Handled by the final event after the streaming is done
-                  end
-                rescue JSON::ParserError => e
-                  # Skip invalid JSON
-                  RubyMCP.logger.warn "Invalid JSON in Anthropic stream: #{e.message}"
-                end
-              end
-            end
-          end
-        rescue Faraday::Error => e
-          raise RubyMCP::Errors::ProviderError, "Anthropic streaming failed: #{e.message}"
-        end
-
-        # Final event
-        if current_tool_calls.any?
-          # Final tool calls event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            tool_calls: current_tool_calls
-          })
-        else
-          # Final content event
-          yield({
-            id: generation_id,
-            event: 'generation.complete',
-            created_at: Time.now.utc.iso8601,
-            content: content_buffer
-          })
-        end
-      end
-
-      def abort_generation(_generation_id)
-        # Anthropic doesn't support aborting generations yet
-        raise RubyMCP::Errors::ProviderError, "Anthropic doesn't support aborting generations"
-      end
-
-      protected
-
-      def default_api_base
-        'https://api.anthropic.com/v1'
-      end
-
-      private
-
-      def format_messages(context)
-        context.messages.map do |msg|
-          # Convert to Anthropic's message format
-          if msg.content_type == 'array'
-            # Handle structured content
-            content_parts = []
-
-            msg.content.each do |part|
-              if part.is_a?(String)
-                content_parts << { 'type' => 'text', 'text' => part }
-              elsif part.is_a?(Hash)
-                if part[:type] == 'text'
-                  content_parts << { 'type' => 'text', 'text' => part[:text] }
-                elsif part[:type] == 'content_pointer'
-                  # We don't have file IDs for Anthropic here
-                  content_parts << { 'type' => 'text', 'text' => "[Content reference: #{part[:content_id]}]" }
-                end
-              end
-            end
-
-            { 'role' => msg.role, 'content' => content_parts }
-          else
-            # Simple text content
-            { 'role' => msg.role, 'content' => msg.content }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/providers/base.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Providers
-    class Base
-      attr_reader :config
-
-      def initialize(config = {})
-        @config = config
-      end
-
-      def list_engines
-        raise NotImplementedError, "#{self.class.name} must implement #list_engines"
-      end
-
-      def generate(context, options = {})
-        raise NotImplementedError, "#{self.class.name} must implement #generate"
-      end
-
-      def generate_stream(context, options = {}, &block)
-        raise NotImplementedError, "#{self.class.name} must implement #generate_stream"
-      end
-
-      def abort_generation(generation_id)
-        raise NotImplementedError, "#{self.class.name} must implement #abort_generation"
-      end
-
-      protected
-
-      def api_key
-        @config[:api_key] || ENV["#{provider_name.upcase}_API_KEY"]
-      end
-
-      def api_base
-        @config[:api_base] || default_api_base
-      end
-
-      def provider_name
-        self.class.name.split('::').last.downcase
-      end
-
-      def default_api_base
-        raise NotImplementedError, "#{self.class.name} must implement #default_api_base"
-      end
-
-      def create_client
-        Faraday.new(url: api_base) do |conn|
-          conn.request :json
-          conn.response :json
-          conn.adapter :net_http
-          conn.headers['Authorization'] = "Bearer #{api_key}"
-          conn.headers['Content-Type'] = 'application/json'
-        end
-      end
-    end
-  end
-end