actionmcp 0.101.0 → 0.103.0

data/lib/action_mcp/client/catalog.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Catalog
-    #
-    # A collection that manages and provides access to resources.
-    # This class stores resource definitions and provides methods for
-    # retrieving, filtering, and accessing resources by URI or other attributes.
-    # It supports lazy loading of resources when initialized with a client.
-    #
-    # Example usage:
-    #   # Eager loading
-    #   resources_data = client.list_resources # Returns array of resource definitions
-    #   catalog = Catalog.new(resources_data)
-    #
-    #   # Lazy loading
-    #   catalog = Catalog.new([], client)
-    #   resources = catalog.all # Resources are loaded here
-    #
-    #   # Access a specific resource by URI
-    #   main_file = catalog.find_by_uri("file:///project/src/main.rs")
-    #
-    #   # Get all resources matching a criteria
-    #   rust_files = catalog.filter { |r| r.mime_type == "text/x-rust" }
-    #
-    class Catalog < Collection
-      # Initialize a new Catalog with resource definitions
-      #
-      # @param resources [Array<Hash>] Array of resource definition hashes, each containing
-      #   uri, name, description, and mimeType keys
-      # @param client [Object, nil] Optional client for lazy loading of resources
-      def initialize(resources, client)
-        super(resources, client)
-        self.resources = @collection_data
-        @load_method = :list_resources
-      end
-
-      # Find a resource by URI
-      #
-      # @param uri [String] URI of the resource to find
-      # @return [Resource, nil] The resource with the given URI, or nil if not found
-      def find_by_uri(uri)
-        all.find { |resource| resource.uri == uri }
-      end
-
-      # Find resources by name
-      #
-      # @param name [String] Name of the resources to find
-      # @return [Array<Resource>] Resources with the given name
-      def find_by_name(name)
-        all.select { |resource| resource.name == name }
-      end
-
-      # Find resources by MIME type
-      #
-      # @param mime_type [String] MIME type to search for
-      # @return [Array<Resource>] Resources with the given MIME type
-      def find_by_mime_type(mime_type)
-        all.select { |resource| resource.mime_type == mime_type }
-      end
-
-      # Get a list of all resource URIs
-      #
-      # @return [Array<String>] URIs of all resources in the collection
-      def uris
-        all.map(&:uri)
-      end
-
-      # Check if the collection contains a resource with the given URI
-      #
-      # @param uri [String] The resource URI to check for
-      # @return [Boolean] true if a resource with the URI exists
-      def contains_uri?(uri)
-        all.any? { |resource| resource.uri == uri }
-      end
-
-      # Group resources by MIME type
-      #
-      # @return [Hash<String, Array<Resource>>] Hash mapping MIME types to arrays of resources
-      def group_by_mime_type
-        all.group_by(&:mime_type)
-      end
-
-      # Search resources by keyword in name or description
-      #
-      # @param keyword [String] Keyword to search for
-      # @return [Array<Resource>] Resources matching the search term
-      def search(keyword)
-        keyword = keyword.downcase
-        all.select do |resource|
-          resource.name.downcase.include?(keyword) ||
-            resource.description&.downcase&.include?(keyword)
-        end
-      end
-
-      # Convert raw resource data into Resource objects
-      #
-      # @param raw_resources [Array<Hash>] Array of resource definition hashes
-      def resources=(raw_resources)
-        @collection_data = raw_resources.map { |resource_data| Resource.new(resource_data) }
-      end
-
-      # Internal Resource class to represent individual resources
-      class Resource
-        attr_reader :uri, :name, :description, :mime_type, :annotations
-
-        # Initialize a new Resource instance
-        #
-        # @param data [Hash] Resource definition hash containing uri, name, description, and mimeType
-        def initialize(data = [])
-          @uri = data["uri"]
-          @name = data["name"]
-          @description = data["description"]
-          @mime_type = data["mimeType"]
-          @annotations = data["annotations"] || {}
-        end
-
-        # Get the file extension from the resource name
-        #
-        # @return [String, nil] The file extension or nil if no extension
-        def extension
-          File.extname(@name)[1..] if @name.include?(".")
-        end
-
-        # Check if this resource is a text file based on MIME type
-        #
-        # @return [Boolean] true if the resource is a text file
-        def text?
-          @mime_type&.start_with?("text/")
-        end
-
-        # Check if this resource is an image based on MIME type
-        #
-        # @return [Boolean] true if the resource is an image
-        def image?
-          @mime_type&.start_with?("image/")
-        end
-
-        # Get the path portion of the URI
-        #
-        # @return [String, nil] The path component of the URI
-        def path
-          URI(@uri).path
-        rescue StandardError
-          nil
-        end
-
-        # Generate a hash representation of the resource
-        #
-        # @return [Hash] Hash containing resource details
-        def to_h
-          {
-            "uri" => @uri,
-            "name" => @name,
-            "description" => @description,
-            "mimeType" => @mime_type,
-            "annotations" => @annotations
-          }
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/collection.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Base collection class for MCP client collections
-    class Collection
-      include RequestTimeouts
-
-      attr_reader :client, :loaded, :next_cursor, :total
-
-      def initialize(items, client, silence_sql: true)
-        @collection_data = items || []
-        @client = client
-        @loaded = !@collection_data.empty?
-        @silence_sql = silence_sql
-        @next_cursor = nil
-        @total = items&.size || 0
-      end
-
-      def all(limit: nil)
-        if limit
-          # If a limit is provided, use pagination
-          result = []
-          each_page(limit: limit) { |page| result.concat(page) }
-          result
-        else
-          # Otherwise, maintain the old behavior
-          silence_logs { load_items unless @loaded }
-          @collection_data
-        end
-      end
-
-      def all!(timeout: DEFAULT_TIMEOUT)
-        silence_logs { load_items(force: true, timeout: timeout) }
-        @collection_data
-      end
-
-      # Fetch a single page of results
-      #
-      # @param cursor [String, nil] Optional cursor for pagination
-      # @param limit [Integer, nil] Optional limit for page size
-      # @return [Array<Object>] The page of items
-      def page(cursor: nil, limit: nil)
-        silence_logs { load_page(cursor: cursor, limit: limit) }
-        @collection_data
-      end
-
-      # Check if there are more pages available
-      #
-      # @return [Boolean] true if there are more pages to fetch
-      def has_more_pages?
-        !@next_cursor.nil?
-      end
-
-      # Fetch the next page of results
-      #
-      # @param limit [Integer, nil] Optional limit for page size
-      # @return [Array<Object>] The next page of items, or empty array if no more pages
-      def next_page(limit: nil)
-        return [] unless has_more_pages?
-
-        page(cursor: @next_cursor, limit: limit)
-      end
-
-      # Iterate through all pages of results
-      #
-      # @param limit [Integer, nil] Optional limit for page size
-      # @yield [page] Block to process each page
-      # @yieldparam page [Array<Object>] A page of items
-      def each_page(limit: nil)
-        return unless block_given?
-
-        current_page = page(limit: limit)
-        yield current_page
-
-        while has_more_pages?
-          current_page = next_page(limit: limit)
-          yield current_page unless current_page.empty?
-        end
-      end
-
-      # Filter items based on a given block
-      #
-      # @yield [item] Block that determines whether to include an item
-      # @yieldparam item [Object] An item from the collection
-      # @yieldreturn [Boolean] true to include the item, false to exclude it
-      # @return [Array<Object>] Items that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
-      # Number of items in the collection
-      #
-      # @return [Integer] The number of items
-      def size
-        all.size
-      end
-
-      # Implements enumerable functionality
-      include Enumerable
-
-      def each(&block)
-        all.each(&block)
-      end
-
-      alias loaded? loaded
-
-      protected
-
-      def load_items(force: false, timeout: DEFAULT_TIMEOUT)
-        return if @loaded && !force
-
-        # Make sure @load_method is defined in the subclass
-        raise NotImplementedError, "Subclass must define @load_method" unless defined?(@load_method)
-
-        # Use the RequestTimeouts module to handle the request
-        load_with_timeout(@load_method, force: force, timeout: timeout)
-      end
-
-      def load_page(cursor: nil, limit: nil, timeout: DEFAULT_TIMEOUT)
-        # Make sure @load_method is defined in the subclass
-        raise NotImplementedError, "Subclass must define @load_method" unless defined?(@load_method)
-
-        # Use the RequestTimeouts module to handle the request with pagination params
-        params = {}
-        params[:cursor] = cursor if cursor
-        params[:limit] = limit if limit
-
-        client.send(@load_method, params)
-
-        start_time = Time.now
-        sleep(0.1) while !@loaded && (Time.now - start_time) < timeout
-
-        # Update @loaded status even if we timed out
-        @loaded = true
-
-        # Return the loaded data
-        @collection_data
-      end
-
-      private
-
-      def silence_logs
-        return yield unless @silence_sql
-
-        original_log_level = ActionMCP::Session.logger&.level
-        begin
-          # Temporarily increase log level to suppress SQL queries
-          ActionMCP::Session.logger.level = Logger::WARN if ActionMCP::Session.logger
-          yield
-        ensure
-          # Restore original log level
-          ActionMCP::Session.logger.level = original_log_level if ActionMCP::Session.logger && original_log_level
-        end
-      end
-
-      def log_error(message)
-        # Safely handle logging - don't assume Rails.logger exists
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.error("[#{self.class.name}] #{message}")
-        else
-          # Fall back to puts if Rails.logger is not available
-          puts "[ERROR] [#{self.class.name}] #{message}"
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/elicitation.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Handles elicitation requests from servers
-    module Elicitation
-      # Process elicitation request from server
-      # @param id [String, Integer] The request ID
-      # @param params [Hash] The elicitation parameters
-      def process_elicitation_request(id, params)
-        params["message"]
-        params["requestedSchema"]
-
-        # In a real implementation, this would prompt the user
-        # For now, we'll just return a decline response
-        # Actual implementations should override this method
-        send_jsonrpc_response(id, result: {
-                                action: "decline"
-                              })
-      end
-
-      # Send elicitation response
-      # @param id [String, Integer] The request ID
-      # @param action [String] The action taken ("accept", "decline", "cancel")
-      # @param content [Hash, nil] The form data if action is "accept"
-      def send_elicitation_response(id, action:, content: nil)
-        result = { action: action }
-        result[:content] = content if action == "accept" && content
-
-        send_jsonrpc_response(id, result: result)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    class JsonRpcHandler < JsonRpcHandlerBase
-      attr_reader :client
-
-      def initialize(transport, client)
-        super(transport)
-        @client = client
-      end
-
-      # Handle client-side JSON-RPC requests/responses
-      # @param request [JSON_RPC::Request, JSON_RPC::Notification, JSON_RPC::Response]
-      def call(request)
-        case request
-        when JSON_RPC::Request
-          handle_request(request)
-        when JSON_RPC::Notification
-          handle_notification(request)
-        when JSON_RPC::Response
-          handle_response(request)
-        end
-      end
-
-      private
-
-      def handle_request(request)
-        id = request.id
-        rpc_method = request.method
-        params = request.params
-
-        handle_method(rpc_method, id, params)
-      end
-
-      def handle_notification(notification)
-        # Handle server notifications to client
-        client.log_debug("Received notification: #{notification.method}")
-      end
-
-      def handle_response(response)
-        # Handle server responses to client requests
-        client.log_debug("Received response: #{response.id} - #{response.result ? 'success' : 'error'}")
-      end
-
-      protected
-
-      # Handle client-specific methods
-      # @param rpc_method [String]
-      # @param id [String, Integer]
-      # @param params [Hash]
-      def handle_method(rpc_method, id, params)
-        case rpc_method
-        when Methods::ELICITATION_CREATE
-          client.process_elicitation_request(id, params)
-        when %r{^roots/}
-          process_roots(rpc_method, id)
-        when %r{^sampling/}
-          process_sampling(rpc_method, id, params)
-        else
-          common_result = handle_common_methods(rpc_method, id, params)
-          client.log_warn("Unknown server method: #{rpc_method} #{id} #{params}") if common_result.nil?
-        end
-      end
-
-      # @param rpc_method [String]
-      # @param id [String]
-      def process_roots(rpc_method, id)
-        case rpc_method
-        when "roots/list" # List available roots
-          transport.send_roots_list(id)
-        else
-          Rails.logger.warn("Unknown roots method: #{rpc_method}")
-        end
-      end
-
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
-      def process_sampling(rpc_method, id, params)
-        case rpc_method
-        when "sampling/createMessage" # Create a message using AI
-          # @param id [String]
-          # @param params [SamplingRequest]
-          transport.send_sampling_create_message(id, params)
-        else
-          Rails.logger.warn("Unknown sampling method: #{rpc_method}")
-        end
-      end
-
-      # @param rpc_method [String]
-      def process_notifications(rpc_method, params)
-        case rpc_method
-        when "notifications/resources/updated" # Resource update notification
-          client.log_debug("Resource #{params['uri']} was updated")
-          # Handle resource update notification
-          # TODO: fetch updated resource or mark it as stale
-        when "notifications/tools/list_changed" # Tool list change notification
-          client.log_debug("Tool list has changed")
-          # Handle tool list change notification
-          # TODO: fetch new tools or mark them as stale
-        when "notifications/prompts/list_changed" # Prompt list change notification
-          client.log_debug("Prompt list has changed")
-          # Handle prompt list change notification
-          # TODO: fetch new prompts or mark them as stale
-        when "notifications/resources/list_changed" # Resource list change notification
-          client.log_debug("Resource list has changed")
-          # Handle resource list change notification
-          # TODO: fetch new resources or mark them as stale
-        else
-          super
-        end
-      end
-
-      def process_response(id, result)
-        # Check if this is a response to an initialize request
-        # We need to check the actual request method, not just compare IDs
-        request = client.session ? transport.messages.requests.find_by(jsonrpc_id: id) : nil
-
-        # If no session yet, this might be the initialize response
-        if !client.session && result["serverInfo"]
-          handle_initialize_response(id, result)
-          return send_initialized_notification
-        end
-
-        return unless request
-
-        # Mark the request as acknowledged
-        request.update(request_acknowledged: true)
-
-        case request.rpc_method
-        when "tools/list"
-          client.toolbox.tools = result["tools"]
-          client.toolbox.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.toolbox.instance_variable_set(:@total, result["tools"]&.size || 0)
-          return true
-        when "prompts/list"
-          client.prompt_book.prompts = result["prompts"]
-          client.prompt_book.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.prompt_book.instance_variable_set(:@total, result["prompts"]&.size || 0)
-          return true
-        when "resources/list"
-          client.catalog.resources = result["resources"]
-          client.catalog.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.catalog.instance_variable_set(:@total, result["resources"]&.size || 0)
-          return true
-        when "resources/templates/list"
-          client.blueprint.templates = result["resourceTemplates"]
-          client.blueprint.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.blueprint.instance_variable_set(:@total, result["resourceTemplates"]&.size || 0)
-          return true
-        end
-
-        client.log_warn("Unknown response: #{id} #{result}")
-      end
-
-      def process_error(id, error)
-        # Do something ?
-        client.log_error("Unknown error: #{id} #{error}")
-      end
-
-      def handle_initialize_response(_request_id, result)
-        # Session ID comes from HTTP headers, not the response body
-        # The transport should have already extracted it
-        session_id = transport.instance_variable_get(:@session_id)
-
-        if session_id.nil?
-          client.log_error("No session ID received from server")
-          return
-        end
-
-        # Check if we're resuming an existing session
-        if client.instance_variable_get(:@session_id) && session_id == client.instance_variable_get(:@session_id)
-          # We're resuming an existing session
-          client.instance_variable_set(:@session, ActionMCP::Session.find(session_id))
-          client.log_info("Resumed existing session: #{session_id}")
-        else
-          # Create a new session with the server-provided ID
-          client.instance_variable_set(:@session, ActionMCP::Session.from_client.new(
-                                                    id: session_id,
-                                                    protocol_version: result["protocolVersion"] || ActionMCP::DEFAULT_PROTOCOL_VERSION,
-                                                    client_info: client.client_info,
-                                                    client_capabilities: client.client_capabilities,
-                                                    server_info: result["serverInfo"],
-                                                    server_capabilities: result["capabilities"]
-                                                  ))
-          client.session.save
-          client.log_info("Created new session: #{session_id}")
-        end
-
-        # Set the server info
-        client.server = Client::Server.new(result)
-        client.instance_variable_set(:@initialized, true)
-      end
-
-      def send_initialized_notification
-        transport.initialize! if transport.respond_to?(:initialize!)
-        client.send_jsonrpc_notification("notifications/initialized")
-      end
-    end
-  end
-end

data/lib/action_mcp/client/logging.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Logging
-      # Set the client's logging level
-      # @param level [String] Logging level (debug, info, warning, error, etc.)
-      # @return [Boolean] Success status
-      def set_logging_level(level)
-        request_id = SecureRandom.uuid_v7
-
-        # Send request
-        send_jsonrpc_request("client/setLoggingLevel",
-                             params: { level: level },
-                             id: request_id)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/messaging.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Messaging
-      def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
-        request = JSON_RPC::Request.new(id: id, method: method, params: params)
-        write_message(request)
-      end
-
-      def send_jsonrpc_response(request_id, result: nil, error: nil)
-        response = JSON_RPC::Response.new(id: request_id, result: result, error: error)
-        write_message(response)
-      end
-
-      def send_jsonrpc_notification(method, params = nil)
-        notification = JSON_RPC::Notification.new(method: method, params: params)
-        write_message(notification)
-      end
-
-      def send_jsonrpc_error(request_id, symbol, message, data = nil)
-        error = JSON_RPC::JsonRpcError.new(symbol, message:, data:)
-        response = JSON_RPC::Response.new(id: request_id, error:)
-        write_message(response)
-      end
-    end
-  end
-end