mcp_lite 2.0.0

data/lib/mcp_lite/executor/resource_reader.rb

@@ -0,0 +1,70 @@
+module McpLite
+  module Executor
+    class ResourceReader
+      def initialize(schema:, context: {})
+        @schema = schema
+        @context = context
+      end
+
+      def read(uri:)
+        unless uri
+          return {
+            isError: true,
+            contents: []
+          }
+        end
+
+        resource = @schema.visible_resources.find do |r|
+          r.uri == uri
+        end
+
+        unless resource
+          return {
+            isError: true,
+            contents: []
+          }
+        end
+
+        if resource.class.respond_to?(:visible?) && !resource.class.visible?(context: @context)
+          return {
+            isError: true,
+            contents: []
+          }
+        end
+
+        begin
+          if resource.respond_to?(:text) && (content = resource.content)
+            {
+              contents: [
+                {
+                  uri:,
+                  mimeType: resource.class.mime_type_value,
+                  text: content
+                }
+              ]
+            }
+          elsif (content = resource.blob)
+            {
+              contents: [
+                {
+                  uri:,
+                  mimeType: resource.class.mime_type_value,
+                  blob: Base64.strict_encode64(content)
+                }
+              ]
+            }
+          end
+        rescue
+          {
+            isError: true,
+            contents: []
+          }
+        end
+      end
+
+      private
+
+      attr_reader :schema, :context
+    end
+  end
+end

data/lib/mcp_lite/executor/tool_executor.rb

@@ -0,0 +1,102 @@
+module McpLite
+  module Executor
+    class ToolExecutor
+      def initialize(schema:, context: {})
+        @schema = schema
+        @context = context
+      end
+
+      def execute(name:, arguments: nil)
+        unless name
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Invalid params: missing tool name"
+              }
+            ]
+          }
+        end
+
+        tool = schema.visible_tools&.find do |tc|
+          tc.class.tool_name_value == name
+        end
+
+        unless tool
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Tool not found: #{name}"
+              }
+            ]
+          }
+        end
+
+        unless tool.class.visible?(context:)
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Unauthorized: Access to tool '#{name}' denied"
+              }
+            ]
+          }
+        end
+
+        args = if arguments.is_a?(String)
+          JSON.parse(arguments, symbolize_names: true)
+        elsif arguments.respond_to?(:to_hash)
+          arguments.to_hash.transform_keys(&:to_sym)
+        else
+          {}
+        end
+
+        args = args.transform_values do |value|
+          if !value.is_a?(String)
+            value
+          else
+            /^\d+$/.match?(value) ? value.to_i : value
+          end
+        end
+
+        validation_result = tool.validate(args, @context)
+
+        if validation_result.is_a?(Hash) && validation_result[:error]
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: validation_result[:error]
+              }
+            ]
+          }
+        end
+
+        begin
+          {
+            content: tool.call(**args, context:)
+          }
+        rescue => e
+          {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Error: #{e.message}"
+              }
+            ]
+          }
+        end
+      end
+
+      private
+
+      attr_reader :schema, :context
+    end
+  end
+end

data/lib/mcp_lite/message/audio.rb

@@ -0,0 +1,22 @@
+module McpLite
+  module Message
+    class Audio
+      def initialize(role:, data:, mime_type:)
+        @role = role
+        @data = data
+        @mime_type = mime_type
+      end
+
+      def to_h
+        {
+          role: @role,
+          content: {
+            type: "audio",
+            data: Base64.strict_encode64(@data),
+            mimeType: @mime_type
+          }
+        }
+      end
+    end
+  end
+end

data/lib/mcp_lite/message/image.rb

@@ -0,0 +1,24 @@
+require 'base64'
+
+module McpLite
+  module Message
+    class Image
+      def initialize(role:, data:, mime_type:)
+        @role = role
+        @data = data
+        @mime_type = mime_type
+      end
+
+      def to_h
+        {
+          role: @role,
+          content: {
+            type: "image",
+            data: Base64.strict_encode64(@data),
+            mimeType: @mime_type
+          }
+        }
+      end
+    end
+  end
+end

data/lib/mcp_lite/message/resource.rb

@@ -0,0 +1,24 @@
+module McpLite
+  module Message
+    class Resource
+      def initialize(role:, resource:)
+        @role = role
+        @resource = resource
+      end
+
+      def to_h
+        {
+          role: @role,
+          content: {
+            type: "resource",
+            resource: {
+              uri: @resource.uri,
+              mimeType: @resource.class.mime_type_value,
+              text: @resource.content
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/mcp_lite/message/text.rb

@@ -0,0 +1,20 @@
+module McpLite
+  module Message
+    class Text
+      def initialize(role:, text:)
+        @role = role
+        @text = text
+      end
+
+      def to_h
+        {
+          role: @role,
+          content: {
+            type: "text",
+            text: @text
+          }
+        }
+      end
+    end
+  end
+end

data/lib/mcp_lite/prompt/base.rb

@@ -0,0 +1,52 @@
+module McpLite
+  module Prompt
+    class Base
+      class << self
+        attr_reader :prompt_name_value, :description_value, :arguments
+
+        def prompt_name(value)
+          @prompt_name_value = value
+        end
+
+        def description(value)
+          @description_value = value
+        end
+
+        def argument(name, required: false, description: "", complete: -> {})
+          @arguments ||= []
+
+          @arguments << {
+            name:,
+            description:,
+            required:,
+            complete:
+          }
+        end
+      end
+
+      def initialize(*args, context: {})
+        @context = context
+      end
+
+      def prompt_name_value
+        self.class.prompt_name_value
+      end
+
+      def description_value
+        self.class.description_value
+      end
+
+      def arguments
+        self.class.arguments
+      end
+
+      def visible?(context: {})
+        true
+      end
+
+      def messages(**args)
+        raise NotImplementedError, "#{self.class.name}#messages must be implemented"
+      end
+    end
+  end
+end

data/lib/mcp_lite/resource/base.rb

@@ -0,0 +1,79 @@
+require "json-schema"
+
+module McpLite
+  module Resource
+    class Base
+      class << self
+        attr_reader :resource_template_name_value, :description_value, :mime_type_value, :uri_template_value, :schema, :arguments
+
+        def resource_template_name(value)
+          @resource_template_name_value = value
+        end
+
+        def uri_template(value)
+          @uri_template_value = value
+        end
+
+        def description(value)
+          @description_value = value
+        end
+
+        def mime_type(value)
+          @mime_type_value = value
+        end
+
+        def argument(name, complete:)
+          @arguments = {}
+          @arguments[name] = complete
+        end
+
+        def visible?(context: {})
+          true
+        end
+      end
+
+      def initialize
+      end
+
+      def visible?(context: {})
+        true
+      end
+
+      def resource_template_name_value
+        self.class.resource_template_name_value
+      end
+
+      def description_value
+        self.class.description_value
+      end
+
+      def mime_type_value
+        self.class.mime_type_value
+      end
+
+      def uri_template_value
+        self.class.uri_template_value
+      end
+
+      def resource_name
+      end
+
+      def uri
+      end
+
+      def description
+      end
+
+      def content
+        case text
+        when String
+          text
+        when Hash
+          text.to_json
+        else
+          text.to_s
+        end
+      end
+    end
+  end
+end

data/lib/mcp_lite/schema/base.rb

@@ -0,0 +1,141 @@
+require_relative "method"
+require_relative "../executor/resource_reader"
+require_relative "../executor/tool_executor"
+
+module McpLite
+  module Schema
+    class Base
+      class << self
+        attr_reader :tools, :resources, :prompts, :context
+
+        def tool(value)
+          @tools ||= []
+          @tools << value
+        end
+
+        def resource(value, items: [])
+          @resources ||= []
+          @resources << {klass: value, items:}
+        end
+
+        def prompt(value)
+          @prompts ||= []
+          @prompts << value
+        end
+
+        def execute(params:, context: {})
+          @context = context
+
+          case params[:method]
+          when Method::INITIALIZE
+            {
+              result: {
+                protocolVersion: "0.1.0",
+                capabilities: {
+                  resources: {},
+                  tools: {},
+                  prompts: {}
+                },
+                serverInfo: {
+                  name: "McpLite",
+                  version: "1.0.0"
+                }
+              }
+            }
+          when Method::INITIALIZED
+            {result: {}}
+          when Method::CANCELLED
+            {result: {}}
+          when Method::RESOURCES_LIST
+            resources = visible_resources.map { |r| {name: r.resource_name, uri: r.uri, description: r.description, mimeType: r.class.mime_type_value } }
+            {result: {resources: resources}}
+          when Method::RESOURCES_TEMPLATES_LIST
+            templates = visible_resource_templates.map { |r| {uriTemplate: r.uri_template_value, name: r.resource_template_name_value} }
+            {result: {resourceTemplates: templates}}
+          when Method::RESOURCES_READ
+            uri = params.dig(:params, :uri)
+            resource = resource_reader.read(uri:)
+            {result: resource}
+          when Method::TOOLS_LIST
+            tools = visible_tools.map do |tool|
+              {
+                name: tool.class.tool_name_value,
+                description: tool.class.description_value,
+                inputSchema: tool.class.render_schema(context),
+              }
+            end
+            {result: {tools: tools}}
+          when Method::TOOLS_CALL
+            name = params.dig(:params, :name)
+            arguments = params.dig(:params, :arguments)
+            unless arguments.is_a?(Hash)
+              arguments = arguments.permit!.to_hash.symbolize_keys
+            end
+            result = tool_executor.execute(name:, arguments:)
+            {result:}
+          when Method::COMPLETION_COMPLETE
+            type = params.dig(:params, :ref, :type)
+            completion = McpLite::Completion.new.complete(
+              params: params[:params],
+              context:,
+              refs: (type == "ref/resource") ? visible_resource_templates : visible_prompts
+            )
+            {result: {completion: completion}}
+          when Method::PROMPTS_LIST
+            prompts = visible_prompts.map do |prompt|
+              {
+                name: prompt.prompt_name_value,
+                description: prompt.description_value,
+                arguments: prompt.arguments.map { _1.except(:complete) } 
+              }
+            end
+            {result: {prompts: prompts}}
+          when Method::PROMPTS_GET
+            prompt = visible_prompts&.find { _1.prompt_name_value == params[:params][:name] }
+            arguments = params.dig(:params, :arguments)
+            unless arguments.is_a?(Hash)
+              arguments = arguments.permit!.to_h.symbolize_keys
+            end
+            messages = prompt.new.messages(**arguments)
+            {result: {messages: messages.map(&:to_h)}}
+          else
+            {result: {}}
+  い        end
+        end
+
+        def visible_resources
+          resources&.filter do |resource|
+            resource[:klass].visible?(context: @context)
+          end&.map do |resource|
+            resource[:items].map do |item|
+              resource[:klass].new(**item)
+            end
+          end&.flatten || []
+        end
+  
+        def visible_resource_templates
+          visibles = resources&.filter do |resource|
+            resource[:klass].uri_template_value && resource[:klass].visible?(context: @context)
+          end
+          visibles&.map { _1[:klass] } || []
+        end
+  
+        def visible_tools
+          tools&.map(&:new) || []
+        end
+  
+        def visible_prompts
+          prompts || []
+        end
+  
+        def resource_reader
+          @resource_reader ||= Executor::ResourceReader.new(schema: self, context:)
+        end
+  
+        def tool_executor
+          @tool_executor ||= Executor::ToolExecutor.new(schema: self, context:)
+        end
+      end
+    end
+  end
+end

data/lib/mcp_lite/schema/method.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module McpLite
+  module Schema
+    module Method
+      INITIALIZE = "initialize"
+      INITIALIZED = "notifications/initialized"
+      CANCELLED = "notifications/cancelled"
+      PING = "ping"
+      TOOLS_LIST = "tools/list"
+      TOOLS_CALL = "tools/call"
+      RESOURCES_LIST = "resources/list"
+      RESOURCES_READ = "resources/read"
+      RESOURCES_TEMPLATES_LIST = "resources/templates/list"
+      COMPLETION_COMPLETE = "completion/complete"
+      PROMPTS_LIST = "prompts/list"
+      PROMPTS_GET = "prompts/get"
+    end
+  end
+end

data/lib/mcp_lite/server/error_code.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module McpLite
+  module ErrorCode
+    NOT_INITIALIZED = -32_002
+    ALREADY_INITIALIZED = -32_002
+
+    PARSE_ERROR = -32_700
+    INVALID_REQUEST = -32_600
+    METHOD_NOT_FOUND = -32_601
+    INVALID_PARAMS = -32_602
+    INTERNAL_ERROR = -32_603
+  end
+end

data/lib/mcp_lite/server/fetcher.rb

@@ -0,0 +1,55 @@
+module McpLite
+  class Server
+    class Fetcher
+      def initialize(base_uri: nil, headers: {})
+        @base_uri = base_uri
+
+        if headers.is_a?(Hash)
+          @headers = headers
+        end
+      end
+
+      def call(params:)
+        return unless @base_uri
+
+        require "net/http"
+
+        unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
+          Server.log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
+          return
+        end
+
+        begin
+          uri = URI.parse(@base_uri.to_s)
+
+          unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
+            Server.log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
+            return
+          end
+        rescue URI::InvalidURIError => e
+          Server.log_error("Invalid URI format", e)
+          return
+        end
+
+        request = Net::HTTP::Post.new(uri)
+        request.body = JSON.generate(params)
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+        @headers.each do |key, value|
+          request[key] = value
+        end
+
+        begin
+          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+
+          JSON.parse(response.body, symbolize_names: true)
+        rescue => e
+          Server.log_error("Error fetching resource_templates", e)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/mcp_lite/server/method.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module McpLite
+  module Method
+    INITIALIZE = "initialize"
+    INITIALIZED = "notifications/initialized"
+    CANCELLED = "notifications/cancelled"
+    PING = "ping"
+    TOOLS_LIST = "tools/list"
+    TOOLS_CALL = "tools/call"
+    RESOURCES_LIST = "resources/list"
+    RESOURCES_READ = "resources/read"
+    RESOURCES_TEMPLATES_LIST = "resources/templates/list"
+    COMPLETION_COMPLETE = "completion/complete"
+    PROMPTS_LIST = "prompts/list"
+    PROMPTS_GET = "prompts/get"
+  end
+end