mcp_lite 2.0.0

data/lib/mcp_lite/server/protocol_handler.rb

@@ -0,0 +1,200 @@
+require "json"
+
+module McpLite
+  class Server
+    class ProtocolHandler
+      attr_reader :initialized
+
+      def initialize(server)
+        @server = server
+        @initialized = false
+        @supported_protocol_versions = [PROTOCOL_VERSION]
+      end
+
+      def process_message(message)
+        message = message.to_s.force_encoding("UTF-8")
+        result = begin
+          request = JSON.parse(message, symbolize_names: true)
+          if !request[:jsonrpc] || !request[:method]
+            error_response(nil, ErrorCode::INVALID_REQUEST, "Invalid JSON-RPC format")
+          else
+            handle_request(request)
+          end
+        rescue JSON::ParserError => e
+          Server.log_error("JSON parse error", e)
+          error_response(nil, ErrorCode::PARSE_ERROR, "Invalid JSON format")
+        rescue => e
+          Server.log_error("Internal error during message processing", e)
+          error_response(nil, ErrorCode::INTERNAL_ERROR, "An internal error occurred")
+        end
+
+        json_result = JSON.generate(result).force_encoding("UTF-8") if result
+        json_result
+      end
+
+      private
+
+      def handle_request(request)
+        case request[:method]
+        when Method::INITIALIZE
+          handle_initialize(request)
+        when Method::INITIALIZED
+          handle_initialized(request)
+        when Method::PING
+          handle_ping(request)
+        when Method::RESOURCES_LIST
+          handle_list_resources(request)
+        when Method::RESOURCES_TEMPLATES_LIST
+          handle_list_resource_templates(request)
+        when Method::TOOLS_LIST
+          handle_list_tools(request)
+        when Method::TOOLS_CALL
+          handle_call_tool(request)
+        when Method::RESOURCES_READ
+          handle_read_resource(request)
+        when Method::COMPLETION_COMPLETE
+          handle_complete(request)
+        when Method::PROMPTS_LIST
+          handle_list_prompts(request)
+        when Method::PROMPTS_GET
+          handle_get_prompt(request)
+        else
+          error_response(request[:id], ErrorCode::METHOD_NOT_FOUND, "Unknown method: #{request[:method]}")
+        end
+      rescue => e
+        Server.log_error("Error #{request[:method]}", e)
+        error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred")
+      end
+
+      def handle_initialize(request)
+        return error_response(request[:id], ErrorCode::ALREADY_INITIALIZED, "Server already initialized") if @initialized
+
+        client_version = request.dig(:params, :protocolVersion)
+
+        unless @supported_protocol_versions.include?(client_version)
+          return error_response(
+            request[:id],
+            ErrorCode::INVALID_PARAMS,
+            "Unsupported protocol version",
+            {
+              supported: @supported_protocol_versions,
+              requested: client_version
+            }
+          )
+        end
+
+        response = {
+          jsonrpc: JSON_RPC_VERSION,
+          id: request[:id],
+          result: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {
+              resources: {},
+              tools: {},
+              prompts: {}
+            },
+            serverInfo: {
+              name: @server.name,
+              version: @server.version
+            }
+          }
+        }
+
+        @initialized = true
+        response
+      end
+
+      def handle_initialized(request)
+        @initialized = true
+        nil
+      end
+
+      def handle_ping(request)
+        success_response(request[:id], {})
+      end
+
+      def handle_list_resources(request)
+        success_response(
+          request[:id],
+          @server.fetch(
+            params: {
+              method: Method::RESOURCES_LIST,
+              params: request[:params]
+            }
+          )[:result]
+        )
+      end
+
+      def handle_list_resource_templates(request)
+        success_response(
+          request[:id],
+          @server.fetch(
+            params: {
+              method: Method::RESOURCES_TEMPLATES_LIST,
+              params: request[:params]
+            }
+          )[:result]
+        )
+      end
+
+      def handle_list_tools(request)
+        success_response(
+          request[:id],
+          @server.fetch(params: {method: Method::TOOLS_LIST, arguments: {}})[:result]
+        )
+      end
+
+      def handle_call_tool(request)
+        name = request.dig(:params, :name)
+        arguments = request.dig(:params, :arguments) || {}
+        result = @server.fetch(params: {method: Method::TOOLS_CALL, params: {name:, arguments:}})
+
+        success_response(request[:id], result[:result])
+      end
+
+      def handle_read_resource(request)
+        uri = request.dig(:params, :uri)
+        result = @server.fetch(params: {method: Method::RESOURCES_READ, params: {uri:, arguments: {}}})
+
+        success_response(request[:id], result[:result])
+      end
+
+      def handle_complete(request)
+        result = @server.fetch(params: {method: Method::COMPLETION_COMPLETE, params: request[:params]})
+        success_response(request[:id], result[:result])
+      end
+
+      def handle_list_prompts(request)
+        result = @server.fetch(params: {method: Method::PROMPTS_LIST})
+        success_response(request[:id], result[:result])
+      end
+
+      def handle_get_prompt(request)
+        result = @server.fetch(params: {method: Method::PROMPTS_GET, params: request[:params]})
+
+        success_response(request[:id], result[:result])
+      end
+
+      def success_response(id, result)
+        {
+          jsonrpc: JSON_RPC_VERSION,
+          id: id,
+          result:
+        }
+      end
+
+      def error_response(id, code, message, data = nil)
+        response = {
+          jsonrpc: JSON_RPC_VERSION,
+          id: id || 0,
+          error: {
+            code:,
+            message:
+          }
+        }
+        response[:error][:data] = data if data
+        response
+      end
+    end
+  end
+end

data/lib/mcp_lite/server/stdio_connection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module McpLite
+  class StdioConnection
+    def initialize
+      $stdout.sync = true
+    end
+
+    def read_next_message
+      message = $stdin.gets&.chomp
+      message.to_s.dup.force_encoding("UTF-8")
+    end
+
+    def send_message(message)
+      message = message.to_s.dup.force_encoding("UTF-8")
+      $stdout.binmode
+      $stdout.write(message + "\n")
+      $stdout.flush
+    end
+  end
+end

data/lib/mcp_lite/server.rb

@@ -0,0 +1,81 @@
+require "json"
+require "English"
+require_relative "server/method"
+require_relative "server/error_code"
+require_relative "server/stdio_connection"
+require_relative "server/fetcher"
+require_relative "server/protocol_handler"
+
+module McpLite
+  class Server
+    class Logger
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def log(message, error = nil)
+        @messages << {message: message, error: error}
+        warn("#{message}: #{error&.message}")
+      end
+    end
+
+    class << self
+      def logger
+        @logger ||= Logger.new
+      end
+
+      def log_error(message, error)
+        logger.log(message, error)
+      end
+    end
+
+    attr_reader :name, :version, :uri, :protocol_handler, :fetcher
+
+    def initialize(
+      version: "1.0.0",
+      name: "McpLite",
+      uri: nil,
+      headers: {}
+    )
+      @name = name
+      @version = version
+      @uri = uri
+      @fetcher = Fetcher.new(base_uri: uri, headers:)
+      @protocol_handler = ProtocolHandler.new(self)
+    end
+
+    def fetch(params:)
+      @fetcher.call(params:)
+    end
+
+    def start
+      serve_stdio
+    end
+
+    def serve_stdio
+      serve(StdioConnection.new)
+    end
+
+    def serve(connection)
+      loop do
+        message = connection.read_next_message
+        break if message.nil?
+
+        response = @protocol_handler.process_message(message)
+        next if response.nil?
+
+        connection.send_message(response)
+      end
+    end
+
+    def initialized
+      @protocol_handler.initialized
+    end
+
+    def tools
+      @tool_manager.tools
+    end
+  end
+end

data/lib/mcp_lite/tool/base.rb

@@ -0,0 +1,68 @@
+require "json-schema"
+
+module McpLite
+  module Tool
+    class Base
+      class << self
+        attr_reader :tool_name_value, :description_value
+
+        def tool_name(value)
+          @tool_name_value = value
+        end
+
+        def description(value)
+          @description_value = value
+        end
+
+        def argument(name, type, required: false, description: "", visible: ->(_context) { true })
+          @schema ||= default_schema
+
+          @schema["properties"][name.to_s] = {"type" => type.to_s, "visible" => visible}
+          @schema["properties"][name.to_s]["description"] = description if description
+          @schema["required"] << name.to_s if required
+        end
+
+        def default_schema
+          {
+            "type" => "object",
+            "properties" => {},
+            "required" => []
+          }
+        end
+
+        def visible?(context: {})
+          true
+        end
+
+        def render_schema(context)
+          return default_schema unless @schema
+
+          {
+            "type" => "object",
+            "properties" => @schema["properties"].filter do |_k, v|
+              v["visible"].call(context)
+            end.map { |k, v| [k, v.except("visible")] }.to_h,
+            "required" => @schema["required"].filter do |item|
+              @schema["properties"][item]["visible"].call(context)
+            end
+          }
+        end
+      end
+
+      def initialize
+      end
+
+      def validate(args, context)
+        return true unless self.class.render_schema(context)
+
+        JSON::Validator.validate!(self.class.render_schema(context), args)
+      rescue JSON::Schema::ValidationError => e
+        {error: e.message}
+      end
+
+      def call(context: {}, **args)
+        raise NotImplementedError, "#{self.class.name}#call must be implemented"
+      end
+    end
+  end
+end

data/lib/mcp_lite/version.rb

@@ -0,0 +1,3 @@
+module McpLite
+  VERSION = "2.0.0"
+end

data/lib/mcp_lite.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "mcp_lite/version"
+require_relative "mcp_lite/configuration"
+require_relative "mcp_lite/schema/base"
+require_relative "mcp_lite/tool/base"
+require_relative "mcp_lite/resource/base"
+require_relative "mcp_lite/prompt/base"
+require_relative "mcp_lite/executor/resource_reader"
+require_relative "mcp_lite/executor/tool_executor"
+require_relative "mcp_lite/message/text"
+require_relative "mcp_lite/message/image"
+require_relative "mcp_lite/message/audio"
+require_relative "mcp_lite/message/resource"
+require_relative "mcp_lite/server"
+require_relative "mcp_lite/completion"
+
+module McpLite
+  JSON_RPC_VERSION = "2.0"
+  PROTOCOL_VERSION = "2024-11-05"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: mcp_lite
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Moeki Kawakami
+bindir: exe
+cert_chain: []
+date: 2025-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby library that provides Model Context Protocol capabilities
+email:
+- hi@moeki.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/mcp_lite.rb
+- lib/mcp_lite/completion.rb
+- lib/mcp_lite/configuration.rb
+- lib/mcp_lite/executor/resource_reader.rb
+- lib/mcp_lite/executor/tool_executor.rb
+- lib/mcp_lite/message/audio.rb
+- lib/mcp_lite/message/image.rb
+- lib/mcp_lite/message/resource.rb
+- lib/mcp_lite/message/text.rb
+- lib/mcp_lite/prompt/base.rb
+- lib/mcp_lite/resource/base.rb
+- lib/mcp_lite/schema/base.rb
+- lib/mcp_lite/schema/method.rb
+- lib/mcp_lite/server.rb
+- lib/mcp_lite/server/error_code.rb
+- lib/mcp_lite/server/fetcher.rb
+- lib/mcp_lite/server/method.rb
+- lib/mcp_lite/server/protocol_handler.rb
+- lib/mcp_lite/server/stdio_connection.rb
+- lib/mcp_lite/tool/base.rb
+- lib/mcp_lite/version.rb
+homepage: https://github.com/moekiorg/mcp_lite
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.6
+specification_version: 4
+summary: Model Context Protocol (MCP) implementation in Ruby
+test_files: []