mcp_on_ruby 0.1.0

data/lib/ruby_mcp/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  class Configuration
+    attr_accessor :providers, :storage, :server_port, :server_host,
+                  :auth_required, :jwt_secret, :token_expiry, :max_contexts
+
+    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
+    end
+
+    def storage_instance
+      @storage_instance ||= case @storage
+                            when :memory
+                              RubyMCP::Storage::Memory.new
+                            when :redis
+                              # Future implementation
+                              raise RubyMCP::Errors::ConfigurationError, 'Redis storage not yet implemented'
+                            when :active_record
+                              # Future implementation
+                              raise RubyMCP::Errors::ConfigurationError, 'ActiveRecord storage not yet implemented'
+                            else
+                              unless @storage.is_a?(RubyMCP::Storage::Base)
+                                raise RubyMCP::Errors::ConfigurationError, "Unknown storage type: #{@storage}"
+                              end
+
+                              @storage # Allow custom storage instance
+
+                            end
+    end
+  end
+end

data/lib/ruby_mcp/errors.rb

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,51 @@
+# 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),
+          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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,60 @@
+# 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

@@ -0,0 +1,269 @@
+# 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

@@ -0,0 +1,57 @@
+# 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