mcp_on_ruby 0.1.0

data/lib/ruby_mcp/providers/openai.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Providers
+    class Openai < Base
+      def list_engines
+        response = create_client.get('models')
+
+        unless response.success?
+          raise RubyMCP::Errors::ProviderError,
+                "Failed to list OpenAI models: #{response.body['error']&.dig('message') || response.status}"
+        end
+
+        models = response.body['data']
+
+        models.map do |model_data|
+          next unless model_data['id'].start_with?('gpt')
+
+          capabilities = ['text-generation']
+          capabilities << 'streaming' if model_data['id'].start_with?('gpt-3.5', 'gpt-4')
+          capabilities << 'tool-calls' if model_data['id'].start_with?('gpt-3.5', 'gpt-4')
+
+          RubyMCP::Models::Engine.new(
+            id: "openai/#{model_data['id']}",
+            provider: 'openai',
+            model: model_data['id'],
+            capabilities: capabilities
+          )
+        end.compact
+      end
+
+      def generate(context, options = {})
+        messages = format_messages(context)
+
+        payload = {
+          model: options[:model],
+          messages: messages,
+          max_tokens: options[:max_tokens],
+          temperature: options[:temperature],
+          top_p: options[:top_p],
+          frequency_penalty: options[:frequency_penalty],
+          presence_penalty: options[:presence_penalty],
+          stop: options[:stop]
+        }.compact
+
+        if options[:tools]
+          payload[:tools] = options[:tools]
+          payload[:tool_choice] = options[:tool_choice] || 'auto'
+        end
+
+        response = create_client.post('chat/completions', payload)
+
+        unless response.success?
+          raise RubyMCP::Errors::ProviderError,
+                "OpenAI generation failed: #{response.body['error']&.dig('message') || response.status}"
+        end
+
+        choice = response.body['choices']&.first
+        content = choice&.dig('message', 'content')
+
+        # Handle tool calls
+        tool_calls = nil
+        if choice&.dig('message', 'tool_calls')
+          tool_calls = choice['message']['tool_calls'].map do |tc|
+            {
+              id: tc['id'],
+              type: 'function',
+              function: {
+                name: tc['function']['name'],
+                arguments: tc['function']['arguments']
+              }
+            }
+          end
+        end
+
+        result = {
+          provider: 'openai',
+          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],
+          temperature: options[:temperature],
+          top_p: options[:top_p],
+          frequency_penalty: options[:frequency_penalty],
+          presence_penalty: options[:presence_penalty],
+          stop: options[:stop],
+          stream: true
+        }.compact
+
+        if options[:tools]
+          payload[:tools] = options[:tools]
+          payload[:tool_choice] = options[:tool_choice] || 'auto'
+        end
+
+        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('chat/completions') do |req|
+            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?
+
+                # Skip "[DONE]" marker
+                next if data.strip == '[DONE]'
+
+                begin
+                  json = JSON.parse(data.strip)
+                  delta = json.dig('choices', 0, 'delta')
+
+                  if delta&.key?('content') && delta['content']
+                    content_buffer += delta['content']
+
+                    # Send content update
+                    yield({
+                      id: generation_id,
+                      event: 'generation.content',
+                      created_at: Time.now.utc.iso8601,
+                      content: delta['content']
+                    })
+                  end
+
+                  # Handle tool call updates
+                  if delta&.key?('tool_calls')
+                    delta['tool_calls'].each do |tc|
+                      tc_id = tc['index']
+
+                      # Initialize tool call if it's new
+                      current_tool_calls[tc_id] ||= {
+                        'id' => SecureRandom.uuid,
+                        'type' => 'function',
+                        'function' => {
+                          'name' => '',
+                          'arguments' => ''
+                        }
+                      }
+
+                      # Update function name
+                      if tc.dig('function', 'name')
+                        current_tool_calls[tc_id]['function']['name'] += tc['function']['name']
+                      end
+
+                      # Update arguments
+                      if tc.dig('function', 'arguments')
+                        current_tool_calls[tc_id]['function']['arguments'] += tc['function']['arguments']
+                      end
+
+                      # Send tool call update
+                      yield({
+                        id: generation_id,
+                        event: 'generation.tool_call',
+                        created_at: Time.now.utc.iso8601,
+                        tool_calls: current_tool_calls
+                      })
+                    end
+                  end
+                rescue JSON::ParserError => e
+                  # Skip invalid JSON
+                  RubyMCP.logger.warn "Invalid JSON in OpenAI stream: #{e.message}"
+                end
+              end
+            end
+          end
+        rescue Faraday::Error => e
+          raise RubyMCP::Errors::ProviderError, "OpenAI 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)
+        # OpenAI doesn't support aborting generations yet
+        raise RubyMCP::Errors::ProviderError, "OpenAI doesn't support aborting generations"
+      end
+
+      protected
+
+      def default_api_base
+        'https://api.openai.com/v1'
+      end
+
+      private
+
+      def format_messages(context)
+        context.messages.map do |msg|
+          # Convert to OpenAI's message format
+          message = { 'role' => msg.role, 'content' => msg.content }
+
+          # Handle structured content
+          if msg.content_type == 'array'
+            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 OpenAI here
+                  # In a real implementation, we would upload the file to OpenAI
+                  content_parts << { 'type' => 'text', 'text' => "[Content reference: #{part[:content_id]}]" }
+                end
+              end
+            end
+
+            message['content'] = content_parts
+          end
+
+          message
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/schemas.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+module RubyMCP
+  module Schemas
+    # Define schemas using dry-schema
+
+    ContextSchema = Dry::Schema.JSON do
+      optional(:id).maybe(:string).filled(format?: /^ctx_[a-zA-Z0-9]+$/)
+
+      optional(:messages).array(:hash) do
+        required(:role).filled(:string, included_in?: %w[user assistant system tool])
+        required(:content).filled
+        optional(:id).maybe(:string)
+        optional(:metadata).maybe(:hash)
+      end
+
+      optional(:metadata).maybe(:hash)
+    end
+
+    MessageSchema = Dry::Schema.JSON do
+      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
+      required(:role).filled(:string, included_in?: %w[user assistant system tool])
+      required(:content).filled
+      optional(:id).maybe(:string)
+      optional(:metadata).maybe(:hash)
+    end
+
+    GenerateSchema = Dry::Schema.JSON do
+      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
+      required(:engine_id).filled(:string, format?: %r{^[a-z0-9-]+/[a-z0-9-]+$})
+
+      optional(:max_tokens).maybe(:integer, gt?: 0)
+      optional(:temperature).maybe(:float, gteq?: 0, lteq?: 2)
+      optional(:top_p).maybe(:float, gteq?: 0, lteq?: 1)
+      optional(:frequency_penalty).maybe(:float, gteq?: -2, lteq?: 2)
+      optional(:presence_penalty).maybe(:float, gteq?: -2, lteq?: 2)
+      optional(:stop).maybe(:string)
+      optional(:update_context).maybe(:bool)
+
+      # Tool calling support could be added here
+    end
+
+    ContentSchema = Dry::Schema.JSON do
+      required(:context_id).filled(:string, format?: /^ctx_[a-zA-Z0-9]+$/)
+      optional(:id).maybe(:string)
+      optional(:type).maybe(:string)
+
+      optional(:file_data).maybe(:string)
+      optional(:filename).maybe(:string)
+      optional(:content_type).maybe(:string)
+      optional(:data).maybe(:hash)
+    end
+  end
+end

data/lib/ruby_mcp/server/app.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'rack/cors'
+require 'json'
+
+module RubyMCP
+  module Server
+    class App
+      attr_reader :config
+
+      def initialize(config = RubyMCP.configuration)
+        @config = config
+        @router = Router.new
+        setup_routes
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Handle CORS preflight requests
+        return [200, {}, []] if request.request_method == 'OPTIONS'
+
+        # Authenticate if required
+        if @config.auth_required && !authenticate(request)
+          return [401, { 'Content-Type' => 'application/json' }, [{ error: 'Unauthorized' }.to_json]]
+        end
+
+        # Route the request
+        response = @router.route(request)
+
+        # Default to 404 if no route matched
+        response || [404, { 'Content-Type' => 'application/json' }, [{ error: 'Not found' }.to_json]]
+      end
+
+      def rack_app
+        app = self
+
+        Rack::Builder.new do
+          use Rack::Cors do
+            allow do
+              origins '*'
+              resource '*',
+                       headers: :any,
+                       methods: %i[get post put delete options]
+            end
+          end
+
+          run app
+        end
+      end
+
+      private
+
+      def setup_routes
+        @router.add('GET', '/engines', EnginesController, :index)
+        @router.add('POST', '/contexts', ContextsController, :create)
+        @router.add('GET', '/contexts', ContextsController, :index)
+        @router.add('GET', '/contexts/:id', ContextsController, :show)
+        @router.add('DELETE', '/contexts/:id', ContextsController, :destroy)
+        @router.add('POST', '/messages', MessagesController, :create)
+        @router.add('POST', '/generate', GenerateController, :create)
+        @router.add('POST', '/generate/stream', GenerateController, :stream)
+        @router.add('POST', '/content', ContentController, :create)
+        @router.add('GET', '/content/:context_id/:id', ContentController, :show)
+      end
+
+      def authenticate(request)
+        auth_header = request.env['HTTP_AUTHORIZATION']
+        return false unless auth_header
+
+        token = auth_header.split(' ').last
+        return false unless token
+
+        begin
+          JWT.decode(token, @config.jwt_secret, true, { algorithm: 'HS256' })
+          true
+        rescue JWT::DecodeError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/base_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class BaseController
+      attr_reader :request, :params
+
+      def initialize(request, params = {})
+        @request = request
+        @params = params
+      end
+
+      protected
+
+      def json_response(status, data)
+        body = data.to_json
+        headers = {
+          'Content-Type' => 'application/json',
+          'Content-Length' => body.bytesize.to_s
+        }
+        [status, headers, [body]]
+      end
+
+      def ok(data = {})
+        json_response(200, data)
+      end
+
+      def created(data = {})
+        json_response(201, data)
+      end
+
+      def bad_request(error = 'Bad request')
+        json_response(400, { error: error })
+      end
+
+      def not_found(error = 'Not found')
+        json_response(404, { error: error })
+      end
+
+      def server_error(error = 'Internal server error')
+        json_response(500, { error: error })
+      end
+
+      def storage
+        RubyMCP.configuration.storage_instance
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/content_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module RubyMCP
+  module Server
+    class ContentController < BaseController
+      def create
+        context_id = params[:context_id]
+        content_id = params[:id] || "cnt_#{SecureRandom.hex(10)}"
+        content_type = params[:type] || 'file'
+
+        begin
+          # Get context to ensure it exists
+          storage.get_context(context_id)
+
+          # Handle file data (base64 encoded)
+          data = if params[:file_data]
+                   {
+                     filename: params[:filename],
+                     content_type: params[:content_type] || 'application/octet-stream',
+                     data: Base64.strict_decode64(params[:file_data])
+                   }
+                 else
+                   params[:data] || {}
+                 end
+
+          # Store the content
+          storage.add_content(context_id, content_id, data)
+
+          created({
+                    id: content_id,
+                    context_id: context_id,
+                    type: content_type
+                  })
+        rescue RubyMCP::Errors::ContextError => e
+          not_found(e.message)
+        rescue ArgumentError => e
+          # Handle base64 decoding errors
+          bad_request("Invalid file_data: #{e.message}")
+        end
+      end
+
+      def show
+        context_id = params[:context_id]
+        content_id = params[:id]
+
+        begin
+          content = storage.get_content(context_id, content_id)
+
+          if content[:filename] && content[:data]
+            # Send file response
+            headers = {
+              'Content-Type' => content[:content_type],
+              'Content-Disposition' => "attachment; filename=\"#{content[:filename]}\""
+            }
+            [200, headers, [content[:data]]]
+          else
+            # Send JSON response
+            ok(content)
+          end
+        rescue RubyMCP::Errors::ContextError, RubyMCP::Errors::ContentError => e
+          not_found(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/contexts_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class ContextsController < BaseController
+      def index
+        limit = (params[:limit] || 50).to_i
+        offset = (params[:offset] || 0).to_i
+
+        contexts = storage.list_contexts(limit: limit, offset: offset)
+        ok({ contexts: contexts.map(&:to_h) })
+      end
+
+      def show
+        context = storage.get_context(params[:id])
+        ok(context.to_h)
+      rescue RubyMCP::Errors::ContextError => e
+        not_found(e.message)
+      end
+
+      def create
+        # Validate the request
+        RubyMCP::Validator.validate_context(params)
+
+        # Create a new context
+        messages = []
+
+        # If messages were provided, create message objects
+        if params[:messages].is_a?(Array)
+          params[:messages].each do |msg|
+            messages << RubyMCP::Models::Message.new(
+              role: msg[:role],
+              content: msg[:content],
+              id: msg[:id],
+              metadata: msg[:metadata]
+            )
+          end
+        end
+
+        # Create the context
+        context = RubyMCP::Models::Context.new(
+          id: params[:id],
+          messages: messages,
+          metadata: params[:metadata]
+        )
+
+        # Store the context
+        storage.create_context(context)
+
+        created(context.to_h)
+      rescue RubyMCP::Errors::ValidationError => e
+        bad_request(e.message)
+      end
+
+      def destroy
+        context = storage.delete_context(params[:id])
+        ok(context.to_h)
+      rescue RubyMCP::Errors::ContextError => e
+        not_found(e.message)
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'rack/handler/webrick'
+
+module RubyMCP
+  module Server
+    class Controller
+      def initialize(config = RubyMCP.configuration)
+        @config = config
+        @app = App.new(config)
+      end
+
+      def start
+        options = {
+          Host: @config.server_host,
+          Port: @config.server_port
+        }
+
+        RubyMCP.logger.info "Starting RubyMCP server on #{@config.server_host}:#{@config.server_port}"
+        Rack::Handler::WEBrick.run @app.rack_app, **options
+      end
+
+      def stop
+        # Nothing to do here yet, but will be useful if we add more complex server
+      end
+    end
+  end
+end

data/lib/ruby_mcp/server/engines_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Server
+    class EnginesController < BaseController
+      def index
+        engines = []
+
+        RubyMCP.configuration.providers.each do |provider_name, provider_config|
+          provider_class = get_provider_class(provider_name)
+          next unless provider_class
+
+          provider = provider_class.new(provider_config)
+          engines.concat(provider.list_engines)
+        end
+
+        ok({ engines: engines.map(&:to_h) })
+      end
+
+      private
+
+      def get_provider_class(provider_name)
+        class_name = provider_name.to_s.capitalize
+
+        if RubyMCP::Providers.const_defined?(class_name)
+          RubyMCP::Providers.const_get(class_name)
+        else
+          RubyMCP.logger.warn "Provider not found: #{provider_name}"
+          nil
+        end
+      end
+    end
+  end
+end