active_mcp 0.5.1 → 0.7.0

data/lib/active_mcp/server/resource_manager.rb

@@ -1,150 +0,0 @@
-require "json"
-
-module ActiveMcp
-  class Server
-    class ResourceManager
-      attr_reader :resources
-
-      def initialize(uri: nil, auth: nil)
-        @resources = {}
-        @base_uri = uri
-
-        if auth
-          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
-        end
-      end
-
-      def load_registered_resources
-        fetch_resources
-      end
-
-      def read_resource(uri)
-        require "net/http"
-        
-        unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI configuration"}]
-          }
-        end
-        
-        begin
-          base_uri = URI.parse(@base_uri.to_s)
-          
-          unless base_uri.scheme =~ /\Ahttps?\z/ && !base_uri.host.nil?
-            log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
-            return {
-              isError: true,
-              content: [{type: "text", text: "Invalid URI configuration"}]
-            }
-          end
-          
-          if defined?(Rails) && Rails.env.production? && base_uri.scheme != "https"
-            return {
-              isError: true,
-              content: [{type: "text", text: "HTTPS is required in production environment"}]
-            }
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI format"}]
-          }
-        end
-        
-        request = Net::HTTP::Post.new(base_uri)
-        request.body = JSON.generate({
-          method: Method::RESOURCES_READ,
-          uri:,
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(base_uri.hostname, base_uri.port) do |http|
-            http.request(request)
-          end
-
-          if response.code == "200"
-            JSON.parse(response.body, symbolize_names: true)
-          else
-            $stderr.puts(response.body)
-            {
-              isError: true,
-              contents: []
-            }
-          end
-        rescue => e
-          log_error("Error calling tool", e)
-          {
-            isError: true,
-            contents: []
-          }
-        end
-      end
-
-      private
-
-      def fetch_resources
-        return unless @base_uri
-
-        require "net/http"
-        
-        unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
-          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?
-            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"
-            log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
-            return
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "resources/list",
-          arguments: "{}"
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          result = JSON.parse(response.body, symbolize_names: true)
-          @resources = result[:result]
-        rescue => e
-          log_error("Error fetching resources", e)
-          @resources = []
-        end
-      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
-          $stderr.puts(error_details)
-        end
-      end
-    end
-  end
-end

data/lib/active_mcp/server/tool_manager.rb

@@ -1,163 +0,0 @@
-require "json"
-
-module ActiveMcp
-  class Server
-    class ToolManager
-      attr_reader :tools
-
-      def initialize(uri: nil, auth: nil)
-        @tools = {}
-        @uri = uri
-
-        if auth
-          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
-        end
-      end
-
-      def call_tool(name, arguments = {})
-        tool_info = @tools.find { _1[:name] == name }
-
-        unless tool_info
-          return {
-            isError: true,
-            content: [{type: "text", text: "Tool not found: #{name}"}]
-          }
-        end
-
-        invoke_tool(name, arguments)
-      end
-
-      def load_registered_tools
-        fetch_tools
-      end
-
-      private
-
-      def invoke_tool(name, arguments)
-        require "net/http"
-        
-        unless @uri.is_a?(URI) || @uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI configuration"}]
-          }
-        end
-        
-        begin
-          uri = URI.parse(@uri.to_s)
-          
-          unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
-            log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
-            return {
-              isError: true,
-              content: [{type: "text", text: "Invalid URI configuration"}]
-            }
-          end
-          
-          if defined?(Rails) && Rails.env.production? && uri.scheme != "https"
-            return {
-              isError: true,
-              content: [{type: "text", text: "HTTPS is required in production environment"}]
-            }
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI format"}]
-          }
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "tools/call",
-          name:,
-          arguments: arguments
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          if response.code == "200"
-            JSON.parse(response.body, symbolize_names: true)
-          else
-            {
-              isError: true,
-              content: [{type: "text", text: "HTTP Error: #{response.code}"}]
-            }
-          end
-        rescue => e
-          log_error("Error calling tool", e)
-          {
-            isError: true,
-            content: [{type: "text", text: "Error calling tool"}]
-          }
-        end
-      end
-
-      def fetch_tools
-        return unless @uri
-
-        require "net/http"
-        
-        unless @uri.is_a?(URI) || @uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return
-        end
-        
-        begin
-          uri = URI.parse(@uri.to_s)
-          
-          unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
-            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"
-            log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
-            return
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "tools/list",
-          arguments: "{}"
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          result = JSON.parse(response.body, symbolize_names: true)
-          @tools = result[:result]
-        rescue => e
-          log_error("Error fetching tools", e)
-          @tools = []
-        end
-      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
-          $stderr.puts(error_details)
-        end
-      end
-    end
-  end
-end

data/lib/active_mcp/tool.rb

@@ -1,82 +0,0 @@
-require "json-schema"
-
-module ActiveMcp
-  class Tool
-    class << self
-      attr_reader :desc, :schema
-
-      def tool_name
-        name ? name.underscore.sub(/_tool$/, "") : ""
-      end
-
-      def description(value)
-        @desc = value
-      end
-
-      def property(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 argument(...)
-        property(...)
-      end
-
-      def registered_tools
-        @registered_tools ||= []
-      end
-
-      attr_writer :registered_tools
-
-      def inherited(subclass)
-        registered_tools << subclass
-      end
-
-      def visible?(auth_info)
-        if respond_to?(:authorized?)
-          authorized?(auth_info)
-        else
-          true
-        end
-      end
-
-      def authorized_tools(auth_info = nil)
-        registered_tools.select do |tool_class|
-          tool_class.visible?(auth_info)
-        end.map do |tool_class|
-          {
-            name: tool_class.tool_name,
-            description: tool_class.desc,
-            inputSchema: tool_class.schema || default_schema
-          }
-        end
-      end
-
-      def default_schema
-        {
-          "type" => "object",
-          "properties" => {},
-          "required" => []
-        }
-      end
-    end
-
-    def initialize
-    end
-
-    def call(**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