fast-mcp 1.4.0 → 1.6.0

data/lib/mcp/server.rb

@@ -8,9 +8,12 @@ require_relative 'transports/stdio_transport'
 require_relative 'transports/rack_transport'
 require_relative 'transports/authenticated_rack_transport'
 require_relative 'logger'
+require_relative 'server_filtering'
 
 module FastMcp
   class Server
+    include ServerFiltering
+
     attr_reader :name, :version, :tools, :resources, :capabilities
 
     DEFAULT_CAPABILITIES = {
@@ -27,14 +30,16 @@ module FastMcp
       @name = name
       @version = version
       @tools = {}
-      @resources = {}
+      @resources = []
       @resource_subscriptions = {}
       @logger = logger
-      @logger.level = Logger::INFO
       @request_id = 0
       @transport_klass = nil
       @transport = nil
       @capabilities = DEFAULT_CAPABILITIES.dup
+      @tool_filters = []
+      @resource_filters = []
+      @on_error_result = nil
 
       # Merge with provided capabilities
       @capabilities.merge!(capabilities) if capabilities.is_a?(Hash)
@@ -66,8 +71,9 @@ module FastMcp
 
     # Register a resource with the server
     def register_resource(resource)
-      @resources[resource.uri] = resource
-      @logger.debug("Registered resource: #{resource.name} (#{resource.uri})")
+      @resources << resource
+
+      @logger.debug("Registered resource: #{resource.resource_name} (#{resource.uri})")
       resource.server = self
       # Notify subscribers about the list change
       notify_resource_list_changed if @transport
@@ -75,10 +81,16 @@ module FastMcp
       resource
     end
 
+    def on_error_result(&block)
+      @on_error_result = block
+    end
+
     # Remove a resource from the server
     def remove_resource(uri)
-      if @resources.key?(uri)
-        resource = @resources.delete(uri)
+      resource = @resources.find { |r| r.uri == uri }
+
+      if resource
+        @resources.delete(resource)
         @logger.debug("Removed resource: #{resource.name} (#{uri})")
 
         # Notify subscribers about the list change
@@ -95,7 +107,7 @@ module FastMcp
       @logger.transport = :stdio
       @logger.info("Starting MCP server: #{@name} v#{@version}")
       @logger.info("Available tools: #{@tools.keys.join(', ')}")
-      @logger.info("Available resources: #{@resources.keys.join(', ')}")
+      @logger.info("Available resources: #{@resources.map(&:resource_name).join(', ')}")
 
       # Use STDIO transport by default
       @transport_klass = FastMcp::Transports::StdioTransport
@@ -105,35 +117,29 @@ module FastMcp
 
     # Start the server as a Rack middleware
     def start_rack(app, options = {})
-      @logger.info("Starting MCP server as Rack middleware: #{@name} v#{@version}")
+      @transport_klass = options.delete(:transport) || FastMcp::Transports::RackTransport
+      transport_name = @transport_klass.name.split('::').last
+
+      @logger.info("Starting MCP server with #{transport_name}: #{@name} v#{@version}")
       @logger.info("Available tools: #{@tools.keys.join(', ')}")
-      @logger.info("Available resources: #{@resources.keys.join(', ')}")
+      @logger.info("Available resources: #{@resources.map(&:resource_name).join(', ')}")
 
-      # Use Rack transport
-      transport_klass = FastMcp::Transports::RackTransport
-      @transport = transport_klass.new(app, self, options.merge(logger: @logger))
+      @transport = @transport_klass.new(app, self, options.merge(logger: @logger))
       @transport.start
 
       # Return the transport as middleware
       @transport
     end
 
-    def start_authenticated_rack(app, options = {})
-      @logger.info("Starting MCP server as Authenticated Rack middleware: #{@name} v#{@version}")
-      @logger.info("Available tools: #{@tools.keys.join(', ')}")
-      @logger.info("Available resources: #{@resources.keys.join(', ')}")
-
-      # Use Rack transport
-      transport_klass = FastMcp::Transports::AuthenticatedRackTransport
-      @transport = transport_klass.new(app, self, options.merge(logger: @logger))
-      @transport.start
+    # Handle a JSON-RPC request and return the response as a JSON string
+    def handle_json_request(request, headers: {})
+      request_str = request.is_a?(String) ? request : JSON.generate(request)
 
-      # Return the transport as middleware
-      @transport
+      handle_request(request_str, headers: headers)
     end
 
     # Handle incoming JSON-RPC request
-    def handle_request(json_str) # rubocop:disable Metrics/MethodLength
+    def handle_request(json_str, headers: {}) # rubocop:disable Metrics/MethodLength
       begin
         request = JSON.parse(json_str)
       rescue JSON::ParserError, TypeError
@@ -142,15 +148,13 @@ module FastMcp
 
       @logger.debug("Received request: #{request.inspect}")
 
-      # Check if it's a valid JSON-RPC 2.0 request
-      unless request['jsonrpc'] == '2.0' && request['method']
-        return send_error(-32_600, 'Invalid Request', request['id'])
-      end
-
       method = request['method']
       params = request['params'] || {}
       id = request['id']
 
+      # Check if it's a valid JSON-RPC 2.0 request
+      return send_error(-32_600, 'Invalid Request', id) unless request['jsonrpc'] == '2.0'
+
       case method
       when 'ping'
         send_result({}, id)
@@ -161,39 +165,26 @@ module FastMcp
       when 'tools/list'
         handle_tools_list(id)
       when 'tools/call'
-        handle_tools_call(params, id)
+        handle_tools_call(params, headers, id)
       when 'resources/list'
         handle_resources_list(id)
+      when 'resources/templates/list'
+        handle_resources_templates_list(id)
       when 'resources/read'
         handle_resources_read(params, id)
       when 'resources/subscribe'
         handle_resources_subscribe(params, id)
       when 'resources/unsubscribe'
         handle_resources_unsubscribe(params, id)
+      when nil
+        # This is a notification response, we don't need to handle it
+        nil
       else
         send_error(-32_601, "Method not found: #{method}", id)
       end
     rescue StandardError => e
       @logger.error("Error handling request: #{e.message}, #{e.backtrace.join("\n")}")
-      send_error(-32_600, "Internal error: #{e.message}", id)
-    end
-
-    # Handle a JSON-RPC request and return the response as a JSON string
-    def handle_json_request(request)
-      # Process the request
-      if request.is_a?(String)
-        handle_request(request)
-      else
-        handle_request(JSON.generate(request))
-      end
-    end
-
-    # Read a resource directly
-    def read_resource(uri)
-      resource = @resources[uri]
-      raise "Resource not found: #{uri}" unless resource
-
-      resource
+      send_error(-32_600, "Internal error: #{e.message}, #{e.backtrace.join("\n")}", id)
     end
 
     # Notify subscribers about a resource update
@@ -215,6 +206,10 @@ module FastMcp
       @transport.send_message(notification)
     end
 
+    def read_resource(uri)
+      @resources.find { |r| r.match(uri) }
+    end
+
     private
 
     PROTOCOL_VERSION = '2024-11-05'
@@ -249,24 +244,34 @@ module FastMcp
 
       return send_error(-32_602, 'Invalid params: missing resource URI', id) unless uri
 
-      resource = @resources[uri]
-      return send_error(-32_602, "Resource not found: #{uri}", id) unless resource
+      @logger.debug("Looking for resource with URI: #{uri}")
 
-      base_content = { uri: resource.uri }
-      base_content[:mimeType] = resource.mime_type if resource.mime_type
-      resource_instance = resource.instance
-      # Format the response according to the MCP specification
-      result = if resource_instance.binary?
-                 {
-                   contents: [base_content.merge(blob: Base64.strict_encode64(resource_instance.content))]
-                 }
-               else
-                 {
-                   contents: [base_content.merge(text: resource_instance.content)]
-                 }
-               end
-
-      send_result(result, id)
+      begin
+        resource = read_resource(uri)
+        return send_error(-32_602, "Resource not found: #{uri}", id) unless resource
+
+        @logger.debug("Found resource: #{resource.resource_name}, templated: #{resource.templated?}")
+
+        base_content = { uri: uri }
+        base_content[:mimeType] = resource.mime_type if resource.mime_type
+        resource_instance = resource.initialize_from_uri(uri)
+        @logger.debug("Resource instance params: #{resource_instance.params.inspect}")
+
+        result = if resource_instance.binary?
+                   {
+                     contents: [base_content.merge(blob: Base64.strict_encode64(resource_instance.content))]
+                   }
+                 else
+                   {
+                     contents: [base_content.merge(text: resource_instance.content)]
+                   }
+                 end
+
+        # # rescue StandardError => e
+        # @logger.error("Error reading resource: #{e.message}")
+        # @logger.error(e.backtrace.join("\n"))
+        send_result(result, id)
+      end
     end
 
     def handle_initialized_notification
@@ -281,18 +286,32 @@ module FastMcp
     # Handle tools/list request
     def handle_tools_list(id)
       tools_list = @tools.values.map do |tool|
-        {
+        tool_info = {
           name: tool.tool_name,
           description: tool.description || '',
           inputSchema: tool.input_schema_to_json || { type: 'object', properties: {}, required: [] }
         }
+
+        # Add annotations if they exist
+        annotations = tool.annotations
+        unless annotations.empty?
+          # Convert snake_case keys to camelCase for MCP protocol
+          camel_case_annotations = {}
+          annotations.each do |key, value|
+            camel_key = key.to_s.gsub(/_([a-z])/) { ::Regexp.last_match(1).upcase }.to_sym
+            camel_case_annotations[camel_key] = value
+          end
+          tool_info[:annotations] = camel_case_annotations
+        end
+
+        tool_info
       end
 
       send_result({ tools: tools_list }, id)
     end
 
     # Handle tools/call request
-    def handle_tools_call(params, id)
+    def handle_tools_call(params, headers, id)
       tool_name = params['name']
       arguments = params['arguments'] || {}
 
@@ -304,7 +323,13 @@ module FastMcp
       begin
         # Convert string keys to symbols for Ruby
         symbolized_args = symbolize_keys(arguments)
-        result, metadata = tool.new.call_with_schema_validation!(**symbolized_args)
+
+        tool_instance = tool.new(headers: headers)
+        authorized = tool_instance.authorized?(**symbolized_args)
+
+        return send_error(-32_602, 'Unauthorized', id) unless authorized
+
+        result, metadata = tool_instance.call_with_schema_validation!(**symbolized_args)
 
         # Format and send the result
         send_formatted_result(result, id, metadata)
@@ -335,6 +360,8 @@ module FastMcp
 
     # Format and send error result
     def send_error_result(message, id)
+      @on_error_result&.call(message)
+
       # Format error according to the MCP specification
       error_result = {
         content: [{ type: 'text', text: "Error: #{message}" }],
@@ -346,11 +373,19 @@ module FastMcp
 
     # Handle resources/list request
     def handle_resources_list(id)
-      resources_list = @resources.values.map(&:metadata)
+      resources_list = @resources.select(&:non_templated?).map(&:metadata)
 
       send_result({ resources: resources_list }, id)
     end
 
+    # Handle resources/templates/list request
+    def handle_resources_templates_list(id)
+      # Collect templated resources
+      templated_resources_list = @resources.select(&:templated?).map(&:metadata)
+
+      send_result({ resourceTemplates: templated_resources_list }, id)
+    end
+
     # Handle resources/subscribe request
     def handle_resources_subscribe(params, id)
       return unless @client_initialized
@@ -362,11 +397,8 @@ module FastMcp
         return
       end
 
-      resource = @resources[uri]
-      unless resource
-        send_error(-32_602, "Resource not found: #{uri}", id)
-        return
-      end
+      resource = @resources.find { |r| r.match(uri) }
+      return send_error(-32_602, "Resource not found: #{uri}", id) unless resource
 
       # Add to subscriptions
       @resource_subscriptions[uri] ||= []

data/lib/mcp/server_filtering.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module FastMcp
+  # Module for handling server filtering functionality
+  module ServerFiltering
+    # Add filter for tools
+    def filter_tools(&block)
+      @tool_filters << block if block_given?
+    end
+
+    # Add filter for resources
+    def filter_resources(&block)
+      @resource_filters << block if block_given?
+    end
+
+    # Check if filters are configured
+    def contains_filters?
+      @tool_filters.any? || @resource_filters.any?
+    end
+
+    # Create a filtered copy for a specific request
+    def create_filtered_copy(request)
+      filtered_server = self.class.new(
+        name: @name,
+        version: @version,
+        logger: @logger,
+        capabilities: @capabilities
+      )
+
+      # Copy transport settings
+      filtered_server.transport_klass = @transport_klass
+
+      # Apply filters and register items
+      register_filtered_tools(filtered_server, request)
+      register_filtered_resources(filtered_server, request)
+
+      filtered_server
+    end
+
+    private
+
+    # Apply tool filters and register filtered tools
+    def register_filtered_tools(filtered_server, request)
+      filtered_tools = apply_tool_filters(request)
+
+      # Register filtered tools
+      filtered_tools.each do |tool|
+        filtered_server.register_tool(tool)
+      end
+    end
+
+    # Apply resource filters and register filtered resources
+    def register_filtered_resources(filtered_server, request)
+      filtered_resources = apply_resource_filters(request)
+
+      # Register filtered resources
+      filtered_resources.each do |resource|
+        filtered_server.register_resource(resource)
+      end
+    end
+
+    # Apply all tool filters to the tools collection
+    def apply_tool_filters(request)
+      filtered_tools = @tools.values
+      @tool_filters.each do |filter|
+        filtered_tools = filter.call(request, filtered_tools)
+      end
+      filtered_tools
+    end
+
+    # Apply all resource filters to the resources collection
+    def apply_resource_filters(request)
+      filtered_resources = @resources
+      @resource_filters.each do |filter|
+        filtered_resources = filter.call(request, filtered_resources)
+      end
+      filtered_resources
+    end
+  end
+end