mcp_on_ruby 0.3.0 → 1.0.0

data/lib/ruby_mcp/server/app.rb

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

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

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

@@ -1,67 +0,0 @@
-# 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_id = params[:id]
-
-        begin
-          storage.delete_context(context_id)
-          ok({ success: true })
-        rescue RubyMCP::Errors::ContextError => e
-          not_found("Context not found: #{e.message}")
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/server/controller.rb

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

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

data/lib/ruby_mcp/server/generate_controller.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Server
-    class GenerateController < BaseController
-      def create
-        context_id = params[:context_id]
-        engine_id = params[:engine_id]
-
-        begin
-          # Get the context
-          context = storage.get_context(context_id)
-
-          # Find the provider
-          provider_name, model = parse_engine_id(engine_id)
-          provider = get_provider(provider_name)
-
-          # Generation options
-          options = {
-            model: model,
-            max_tokens: params[:max_tokens],
-            temperature: params[:temperature],
-            top_p: params[:top_p],
-            frequency_penalty: params[:frequency_penalty],
-            presence_penalty: params[:presence_penalty],
-            stop: params[:stop]
-          }.compact
-
-          # Generate the response
-          response = provider.generate(context, options)
-
-          # Add the assistant message to the context if requested
-          if params[:update_context] != false
-            message = RubyMCP::Models::Message.new(
-              role: 'assistant',
-              content: response[:content],
-              metadata: response[:metadata]
-            )
-            storage.add_message(context_id, message)
-          end
-
-          ok(response)
-        rescue RubyMCP::Errors::ContextError => e
-          not_found(e.message)
-        rescue RubyMCP::Errors::ProviderError, RubyMCP::Errors::EngineError => e
-          bad_request(e.message)
-        end
-      end
-
-      def stream
-        context_id = params[:context_id]
-        engine_id = params[:engine_id]
-
-        # Check that we have a streaming-compatible request
-        return bad_request('Streaming requires HTTP/1.1 or higher') unless request.env['HTTP_VERSION'] == 'HTTP/1.1'
-
-        begin
-          # Get the context
-          context = storage.get_context(context_id)
-
-          # Find the provider
-          provider_name, model = parse_engine_id(engine_id)
-          provider = get_provider(provider_name)
-
-          # Generation options
-          options = {
-            model: model,
-            max_tokens: params[:max_tokens],
-            temperature: params[:temperature],
-            top_p: params[:top_p],
-            frequency_penalty: params[:frequency_penalty],
-            presence_penalty: params[:presence_penalty],
-            stop: params[:stop]
-          }.compact
-
-          # Prepare streaming response
-          headers = {
-            'Content-Type' => 'text/event-stream',
-            'Cache-Control' => 'no-cache',
-            'Connection' => 'keep-alive'
-          }
-
-          # Start streaming
-          chunked_body = Enumerator.new do |yielder|
-            complete_message = ''
-
-            # Stream the response
-            provider.generate_stream(context, options) do |chunk|
-              data = chunk.to_json
-              yielder << "data: #{data}\n\n"
-
-              # Accumulate content for final message
-              complete_message += chunk[:content] if chunk[:content]
-            end
-
-            # Add the complete message to context if requested
-            if params[:update_context] != false && !complete_message.empty?
-              message = RubyMCP::Models::Message.new(
-                role: 'assistant',
-                content: complete_message
-              )
-              storage.add_message(context_id, message)
-            end
-
-            # End the stream
-            yielder << "data: [DONE]\n\n"
-          end
-
-          [200, headers, chunked_body]
-        rescue RubyMCP::Errors::ContextError => e
-          not_found(e.message)
-        rescue RubyMCP::Errors::ProviderError, RubyMCP::Errors::EngineError => e
-          bad_request(e.message)
-        end
-      end
-
-      private
-
-      def parse_engine_id(engine_id)
-        parts = engine_id.to_s.split('/', 2)
-        raise RubyMCP::Errors::ValidationError, 'Invalid engine_id format' unless parts.length == 2
-
-        parts
-      end
-
-      def get_provider(provider_name)
-        provider_config = RubyMCP.configuration.providers[provider_name.to_sym]
-        raise RubyMCP::Errors::ProviderError, "Provider not configured: #{provider_name}" unless provider_config
-
-        class_name = provider_name.to_s.capitalize
-        unless RubyMCP::Providers.const_defined?(class_name)
-          raise RubyMCP::Errors::ProviderError, "Provider not found: #{provider_name}"
-        end
-
-        provider_class = RubyMCP::Providers.const_get(class_name)
-        provider_class.new(provider_config)
-      end
-    end
-  end
-end

data/lib/ruby_mcp/server/messages_controller.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Server
-    class MessagesController < BaseController
-      def create
-        context_id = params[:context_id]
-
-        begin
-          # Create the message
-          message = RubyMCP::Models::Message.new(
-            role: params[:role],
-            content: params[:content],
-            id: params[:id],
-            metadata: params[:metadata]
-          )
-
-          # Add to the context
-          storage.add_message(context_id, message)
-
-          created(message.to_h)
-        rescue RubyMCP::Errors::ContextError => e
-          not_found(e.message)
-        rescue RubyMCP::Errors::ValidationError => e
-          bad_request(e.message)
-        end
-      end
-    end
-  end
-end

data/lib/ruby_mcp/server/router.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RubyMCP
-  module Server
-    class Router
-      Route = Struct.new(:http_method, :path, :controller, :action)
-
-      def initialize
-        @routes = []
-      end
-
-      def add(method, path, controller, action)
-        @routes << Route.new(method, path, controller, action)
-      end
-
-      def route(request)
-        route = find_route(request.request_method, request.path)
-        return nil unless route
-
-        params = extract_params(route.path, request.path)
-
-        # Add body params for non-GET requests
-        if request.post? || request.put?
-          begin
-            body_params = JSON.parse(request.body.read, symbolize_names: true)
-            params.merge!(body_params)
-          rescue JSON::ParserError
-            # Handle empty or invalid JSON
-          end
-        end
-
-        # Add query params
-        params.merge!(extract_query_params(request))
-
-        # Initialize the controller and call the action
-        controller = route.controller.new(request, params)
-        controller.send(route.action)
-      end
-
-      private
-
-      def find_route(method, path)
-        @routes.find do |route|
-          route.http_method == method && path_matches?(route.path, path)
-        end
-      end
-
-      def path_matches?(route_path, request_path)
-        route_parts = route_path.split('/')
-        request_parts = request_path.split('/')
-
-        return false if route_parts.length != request_parts.length
-
-        route_parts.zip(request_parts).all? do |route_part, request_part|
-          route_part.start_with?(':') || route_part == request_part
-        end
-      end
-
-      def extract_params(route_path, request_path)
-        params = {}
-
-        route_parts = route_path.split('/')
-        request_parts = request_path.split('/')
-
-        route_parts.zip(request_parts).each do |route_part, request_part|
-          if route_part.start_with?(':')
-            param_name = route_part[1..].to_sym
-            params[param_name] = request_part
-          end
-        end
-
-        params
-      end
-
-      def extract_query_params(request)
-        params = {}
-        request.params.each do |key, value|
-          params[key.to_sym] = value
-        end
-        params
-      end
-    end
-  end
-end