active_mcp 0.5.1 → 0.7.0

data/lib/active_mcp/engine.rb

@@ -2,20 +2,17 @@ module ActiveMcp
   class Engine < ::Rails::Engine
     isolate_namespace ActiveMcp
 
-    initializer "active_mcp.eager_load_tools" do |app|
-      tools_path = Rails.root.join("app", "tools")
-      if Dir.exist?(tools_path)
-        Dir[tools_path.join("*.rb")].sort.each do |file|
-          require_dependency file
-        end
-      end
-    end
-
-    initializer "active_mcp.eager_load_resources" do |app|
-      tools_path = Rails.root.join("app", "resources")
-      if Dir.exist?(tools_path)
-        Dir[tools_path.join("*.rb")].sort.each do |file|
-          require_dependency file
+    initializer "active_mcp.eager_load" do |app|
+      [
+        Rails.root.join("app", "mcp", "tools"),
+        Rails.root.join("app", "mcp", "resources"),
+        Rails.root.join("app", "mcp", "resource_templates"),
+        Rails.root.join("app", "mcp", "schemas")
+      ].each do |tools_path|
+        if Dir.exist?(tools_path)
+          Dir[tools_path.join("*.rb")].sort.each do |file|
+            require_dependency file
+          end
         end
       end
     end

data/lib/active_mcp/schema/base.rb

@@ -0,0 +1,46 @@
+module ActiveMcp
+  module Schema
+    class Base
+      class << self
+        attr_reader :resources, :resource_templates, :tools
+
+        def resource(klass)
+          @resources ||= []
+          @resources << klass
+        end
+
+        def resource_template(klass)
+          @resource_templates ||= []
+          @resource_templates << klass
+        end
+
+        def tool(klass)
+          @tools ||= []
+          @tools << klass
+        end
+      end
+
+      def initialize(context: {})
+        @context = context
+      end
+
+      def resources
+        self.class.resources.filter do |resource|
+          !resource.respond_to?(:visible?) || resource.visible?(context: @context)
+        end
+      end
+
+      def resource_templates
+        self.class.resource_templates.filter do |tool_resource|
+          !tool_resource.respond_to?(:visible?) || tool_resource.visible?(context: @context)
+        end
+      end
+
+      def tools
+        self.class.tools.filter do |tool|
+          !tool.respond_to?(:visible?) || tool.visible?(context: @context)
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server/fetcher.rb

@@ -0,0 +1,56 @@
+module ActiveMcp
+  class Server
+    class Fetcher
+      def initialize(base_uri: nil, auth: nil)
+        @base_uri = base_uri
+
+        if auth
+          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
+        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
+          
+          if defined?(Rails) && Rails.env.production? && uri.scheme != "https"
+            Server.log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
+            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["Authorization"] = @auth_header
+
+        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)
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server/method.rb

@@ -10,6 +10,6 @@ module ActiveMcp
     TOOLS_CALL = "tools/call"
     RESOURCES_LIST = "resources/list"
     RESOURCES_READ = "resources/read"
-    RESOURCES_TEMPLATES_LIST = "resources/list"
+    RESOURCES_TEMPLATES_LIST = "resources/templates/list"
   end
 end

data/lib/active_mcp/server/protocol_handler.rb

@@ -17,10 +17,10 @@ module ActiveMcp
           request = JSON.parse(message, symbolize_names: true)
           handle_request(request)
         rescue JSON::ParserError => e
-          log_error("JSON parse error", e)
+          Server.log_error("JSON parse error", e)
           error_response(nil, ErrorCode::PARSE_ERROR, "Invalid JSON format")
         rescue => e
-          log_error("Internal error during message processing", e)
+          Server.log_error("Internal error during message processing", e)
           error_response(nil, ErrorCode::INTERNAL_ERROR, "An internal error occurred")
         end
 
@@ -50,10 +50,12 @@ module ActiveMcp
           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_use_tool(request)
+          handle_call_tool(request)
         when Method::RESOURCES_READ
           handle_read_resource(request)
         else
@@ -113,23 +115,63 @@ module ActiveMcp
       end
 
       def handle_list_resources(request)
-        success_response(request[:id], {resources: @server.resource_manager.resources})
+        success_response(
+          request[:id],
+          {
+            resources: @server.fetch(
+              params: {
+                method: Method::RESOURCES_LIST,
+                arguments: {}
+              }
+            )[:result]
+          }
+        )
+      end
+
+      def handle_list_resource_templates(request)
+        success_response(
+          request[:id],
+          {
+            resourceTemplates: @server.fetch(
+              params: {
+                method: Method::RESOURCES_TEMPLATES_LIST,
+                arguments: {}
+              }
+            )[:result]
+          }
+        )
       end
 
       def handle_list_tools(request)
-        success_response(request[:id], {tools: @server.tool_manager.tools})
+        success_response(
+          request[:id],
+          {
+            tools: @server.fetch(
+              params: {
+                method: Method::TOOLS_LIST,
+                arguments: {}
+              }
+            )[:result]
+          }
+        )
       end
 
-      def handle_use_tool(request)
+      def handle_call_tool(request)
         name = request.dig(:params, :name)
         arguments = request.dig(:params, :arguments) || {}
 
         begin
-          result = @server.tool_manager.call_tool(name, arguments)
+          result = @server.fetch(
+            params: {
+              method: Method::TOOLS_CALL,
+              name:,
+              arguments:,
+            }
+          )
 
           success_response(request[:id], result)
         rescue => e
-          log_error("Error calling tool #{name}", e)
+          Server.log_error("Error calling tool #{name}", e)
           error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while calling the tool")
         end
       end
@@ -137,11 +179,17 @@ module ActiveMcp
       def handle_read_resource(request)
         uri = request.dig(:params, :uri)
         begin
-          result = @server.resource_manager.read_resource(uri)
+          result = @server.fetch(
+            params: {
+              method: Method::RESOURCES_READ,
+              uri:,
+              arguments: {},
+            }
+          )
 
           success_response(request[:id], result)
         rescue => e
-          log_error("Error reading resource #{uri}", e)
+          Server.("Error reading resource #{uri}", e)
           error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
         end
       end
@@ -166,18 +214,6 @@ module ActiveMcp
         response[:error][:data] = data if data
         response
       end
-      
-      def log_error(message, error)
-        error_details = "#{message}: #{error.message}\n"
-        error_details += error.backtrace.join("\n") if error.backtrace
-        
-        if defined?(Rails)
-          Rails.logger.error(error_details)
-        else
-          # Fresallback to standard error output if Rails is not available
-          $stderr.puts(error_details)
-        end
-      end
     end
   end
 end

data/lib/active_mcp/server.rb

@@ -3,13 +3,12 @@ require "English"
 require_relative "server/method"
 require_relative "server/error_codes"
 require_relative "server/stdio_connection"
-require_relative "server/resource_manager"
-require_relative "server/tool_manager"
+require_relative "server/fetcher"
 require_relative "server/protocol_handler"
 
 module ActiveMcp
   class Server
-    attr_reader :name, :version, :uri, :tool_manager, :protocol_handler, :resource_manager
+    attr_reader :name, :version, :uri, :protocol_handler, :fetcher
 
     def initialize(
       version: ActiveMcp::VERSION,
@@ -20,11 +19,23 @@ module ActiveMcp
       @name = name
       @version = version
       @uri = uri
-      @resource_manager = ResourceManager.new(uri:, auth:)
-      @tool_manager = ToolManager.new(uri: uri, auth:)
+      @fetcher = Fetcher.new(base_uri: uri, auth:)
       @protocol_handler = ProtocolHandler.new(self)
-      @tool_manager.load_registered_tools
-      @resource_manager.load_registered_resources
+    end
+
+    def self.log_error(message, error)
+      error_details = "#{message}: #{error.message}\n"
+      error_details += error.backtrace.join("\n") if error.backtrace
+      
+      if defined?(Rails)
+        Rails.logger.error(error_details)
+      else
+        $stderr.puts(error_details)
+      end
+    end
+
+    def fetch(params:)
+      @fetcher.call(params:)
     end
 
     def start

data/lib/active_mcp/tool/base.rb

@@ -0,0 +1,52 @@
+require "json-schema"
+
+module ActiveMcp
+  module Tool
+    class Base
+      class << self
+        attr_reader :schema
+
+        def argument(name, type, required: false, description: nil)
+          @schema ||= default_schema
+
+          @schema["properties"][name.to_s] = {"type" => type.to_s}
+          @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
+      end
+
+      def initialize
+      end
+
+      def name
+      end
+
+      def description
+      end
+
+      def visible?(context: {})
+        true
+      end
+
+      def call(context: {}, **args)
+        raise NotImplementedError, "#{self.class.name}#call must be implemented"
+      end
+
+      def validate_arguments(args)
+        return true unless self.class.schema
+
+        JSON::Validator.validate!(self.class.schema, args)
+      rescue JSON::Schema::ValidationError => e
+        {error: e.message}
+      end
+    end
+  end
+end

data/lib/active_mcp/version.rb

@@ -1,3 +1,3 @@
 module ActiveMcp
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

data/lib/active_mcp.rb

@@ -3,11 +3,13 @@
 require "jbuilder"
 require_relative "active_mcp/version"
 require_relative "active_mcp/configuration"
-require_relative "active_mcp/tool"
+require_relative "active_mcp/schema/base"
+require_relative "active_mcp/tool/base"
 require_relative "active_mcp/server"
 
 if defined? ::Rails
   require_relative "active_mcp/engine"
+  require_relative "active_mcp/controller/base"
 end
 
 module ActiveMcp

data/lib/generators/active_mcp/install/install_generator.rb

@@ -2,16 +2,12 @@ module ActiveMcp
   module Generators
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path('templates', __dir__)
-      
-      desc "Creates an Active MCP initializer and mounts the engine in your routes"
-      
+
+      desc "Creates an Active MCP initializer"
+
       def create_initializer_file
         template "initializer.rb", "config/initializers/active_mcp.rb"
       end
-      
-      def update_routes
-        route "mount ActiveMcp::Engine, at: '/mcp'"
-      end
     end
   end
 end

data/lib/generators/active_mcp/resource/resource_generator.rb

@@ -4,7 +4,7 @@ module ActiveMcp
       source_root File.expand_path("templates", __dir__)
 
       def create_resource_file
-        template "resource.rb.erb", File.join("app/resources", "#{file_name}_resource.rb")
+        template "resource.rb.erb", File.join("app/mcp/resources", "#{file_name}_resource.rb")
       end
 
       private

data/lib/generators/active_mcp/resource/templates/resource.rb.erb

@@ -1,12 +1,4 @@
 class <%= class_name %>
-  def initialize(auth_info:)
-    @auth_info = auth_info
-
-    # Authentication information can be accessed via @auth_info parameter
-    # @auth_info = { type: :bearer, token: "xxx", header: "Bearer xxx" }
-    # or { type: :basic, token: "base64encoded", header: "Basic base64encoded" }
-  end
-
   def name
     "<%= file_name %>"
   end
@@ -25,16 +17,16 @@ class <%= class_name %>
 
   # Uncomment and modify this method to implement authorization control
   # This controls who can see and use this tool
-  # def visible?
+  # def visible?(context: {})
   #   # Example: require authentication
-  #   # return false unless @auth_info
+  #   # return false unless context
   #   
   #   # Example: require a specific authentication type
-  #   # return false unless @auth_info[:type] == :bearer
+  #   # return false unless context[:auth_info][:type] == :bearer
   #   
   #   # Example: check for admin permissions
   #   # admin_tokens = ["admin-token"]
-  #   # return admin_tokens.include?(@auth_info[:token])
+  #   # return admin_tokens.include?(context[:auth_info][:token])
   #   
   #   # Default: allow all access
   #   true

data/lib/generators/active_mcp/tool/templates/tool.rb.erb

@@ -1,5 +1,11 @@
-class <%= class_name %> < ActiveMcp::Tool
-  description "<%= file_name.humanize %>"
+class <%= class_name %> < ActiveMcp::Tool::Base
+  def name
+    "<%= file_name.humanize %>"
+  end
+
+  def description
+    "<%= file_name.humanize %>"
+  end
   
   argument :param1, :string, required: true, description: "First parameter description"
   argument :param2, :string, required: false, description: "Second parameter description"
@@ -7,25 +13,25 @@ class <%= class_name %> < ActiveMcp::Tool
   
   # Uncomment and modify this method to implement authorization control
   # This controls who can see and use this tool
-  # def self.visible?(auth_info)
+  # def visible?(context: {})
   #   # Example: require authentication
-  #   # return false unless auth_info
+  #   # return false unless context
   #   
   #   # Example: require a specific authentication type
-  #   # return false unless auth_info[:type] == :bearer
+  #   # return false unless context[:auth_info][:type] == :bearer
   #   
   #   # Example: check for admin permissions
   #   # admin_tokens = ["admin-token"]
-  #   # return admin_tokens.include?(auth_info[:token])
+  #   # return admin_tokens.include?(context[:auth_info][:token])
   #   
   #   # Default: allow all access
   #   true
   # end
   
-  def call(param1:, param2: nil, auth_info: nil, **args)
+  def call(param1:, param2: nil, context: {})
     # Authentication information can be accessed via _auth_info parameter
-    # auth_info = { type: :bearer, token: "xxx", header: "Bearer xxx" }
-    # or { type: :basic, token: "base64encoded", header: "Basic base64encoded" }
+    # context = { auth_info: { type: :bearer, token: "xxx", header: "Bearer xxx" } }
+    # or { auth_info: { type: :basic, token: "base64encoded", header: "Basic base64encoded" } }
 
     # Implement tool logic here
 

data/lib/generators/active_mcp/tool/tool_generator.rb

@@ -4,7 +4,7 @@ module ActiveMcp
       source_root File.expand_path("templates", __dir__)
 
       def create_tool_file
-        template "tool.rb.erb", File.join("app/tools", "#{file_name}_tool.rb")
+        template "tool.rb.erb", File.join("app/mcp/tools", "#{file_name}_tool.rb")
       end
 
       private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mcp
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Moeki Kawakami
@@ -68,6 +68,7 @@ files:
 - README.md
 - Rakefile
 - app/controllers/active_mcp/base_controller.rb
+- app/controllers/concerns/active_mcp/authenticatable.rb
 - app/controllers/concerns/active_mcp/request_handlable.rb
 - app/controllers/concerns/active_mcp/resource_readable.rb
 - app/controllers/concerns/active_mcp/tool_executable.rb
@@ -75,6 +76,7 @@ files:
 - app/views/active_mcp/initialize.json.jbuilder
 - app/views/active_mcp/initialized.json.jbuilder
 - app/views/active_mcp/no_method.json.jbuilder
+- app/views/active_mcp/resource_templates_list.json.jbuilder
 - app/views/active_mcp/resources_list.json.jbuilder
 - app/views/active_mcp/resources_read.json.jbuilder
 - app/views/active_mcp/tools_call.json.jbuilder
@@ -82,15 +84,16 @@ files:
 - config/routes.rb
 - lib/active_mcp.rb
 - lib/active_mcp/configuration.rb
+- lib/active_mcp/controller/base.rb
 - lib/active_mcp/engine.rb
+- lib/active_mcp/schema/base.rb
 - lib/active_mcp/server.rb
 - lib/active_mcp/server/error_codes.rb
+- lib/active_mcp/server/fetcher.rb
 - lib/active_mcp/server/method.rb
 - lib/active_mcp/server/protocol_handler.rb
-- lib/active_mcp/server/resource_manager.rb
 - lib/active_mcp/server/stdio_connection.rb
-- lib/active_mcp/server/tool_manager.rb
-- lib/active_mcp/tool.rb
+- lib/active_mcp/tool/base.rb
 - lib/active_mcp/version.rb
 - lib/generators/active_mcp/install/install_generator.rb
 - lib/generators/active_mcp/install/templates/initializer.rb