actionmcp 0.102.0 → 0.104.0

data/lib/action_mcp/client/base.rb

@@ -1,225 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "transport"
-
-module ActionMCP
-  module Client
-    # Base client class containing common MCP functionality
-    class Base
-      # Include all transport protocol modules
-      include Messaging
-      include Tools
-      include Prompts
-      include Resources
-      include Roots
-      include Elicitation
-
-      attr_reader :logger, :transport,
-                  :connection_error, :server,
-                  :server_capabilities, :session,
-                  :catalog, :blueprint,
-                  :prompt_book, :toolbox
-
-      delegate :connected?, :ready?, to: :transport
-
-      def initialize(transport:, logger: ActionMCP.logger, protocol_version: nil, **options)
-        @logger = logger
-        @transport = transport
-        @session = nil # Session will be created/loaded based on server response
-        @session_id = options[:session_id] # Optional session ID for resumption
-        @protocol_version = protocol_version || ActionMCP::DEFAULT_PROTOCOL_VERSION
-        @server_capabilities = nil
-        @connection_error = nil
-        @initialized = false
-
-        # Resource objects
-        @catalog = Catalog.new([], self)
-        # Resource template objects
-        @blueprint = Blueprint.new([], self)
-        # Prompt objects
-        @prompt_book = PromptBook.new([], self)
-        # Tool objects
-        @toolbox = Toolbox.new([], self)
-
-        setup_transport_callbacks
-      end
-
-      # Connect to the MCP server
-      def connect
-        return true if connected?
-
-        begin
-          log_debug("Connecting to MCP server via #{transport.class.name}...")
-          @connection_error = nil
-
-          success = @transport.connect
-          unless success
-            log_error("Failed to establish transport connection")
-            return false
-          end
-
-          log_debug("Connected to MCP server")
-          true
-        rescue StandardError => e
-          @connection_error = e.message
-          log_error("Failed to connect to MCP server: #{e.message}")
-          false
-        end
-      end
-
-      # Disconnect from the MCP server
-      def disconnect
-        return true unless connected?
-
-        begin
-          @transport.disconnect
-          log_debug("Disconnected from MCP server")
-          true
-        rescue StandardError => e
-          log_error("Error disconnecting from MCP server: #{e.message}")
-          false
-        end
-      end
-
-      # Send a request to the MCP server
-      def write_message(payload)
-        unless ready?
-          log_error("Cannot send request - transport not ready")
-          return false
-        end
-
-        begin
-          # Only write to session if it exists (after initialization)
-          session&.write(payload)
-          data = payload.to_json unless payload.is_a?(String)
-          @transport.send_message(data)
-          true
-        rescue StandardError => e
-          log_error("Failed to send request: #{e.message}")
-          false
-        end
-      end
-
-      def server=(server)
-        @server = if server.is_a?(Client::Server)
-                    server
-        else
-                    Client::Server.new(server)
-        end
-
-        # Only update session if it exists
-        return unless @session
-
-        @session.server_capabilities = server.capabilities
-        @session.server_info = server.server_info
-        @session.save
-      end
-
-      def initialized?
-        @initialized && @session&.initialized?
-      end
-
-      def inspect
-        session_info = @session ? "session: #{@session.id}" : "session: none"
-        "#<#{self.class.name} transport: #{transport.class.name}, server: #{server}, client_name: #{client_info[:name]}, client_version: #{client_info[:version]}, capabilities: #{client_capabilities}, connected: #{connected?}, initialized: #{initialized?}, #{session_info}>"
-      end
-
-      protected
-
-      def setup_transport_callbacks
-        # Create JSON-RPC handler
-        @json_rpc_handler = JsonRpcHandler.new(session, self)
-
-        # Set up transport callbacks
-        @transport.on_message do |message|
-          handle_raw_message(message)
-        end
-
-        @transport.on_error do |error|
-          handle_transport_error(error)
-        end
-
-        @transport.on_connect do
-          handle_transport_connect
-        end
-
-        @transport.on_disconnect do
-          handle_transport_disconnect
-        end
-      end
-
-      def handle_raw_message(raw)
-        @json_rpc_handler.call(raw)
-      rescue MultiJson::ParseError => e
-        log_error("JSON parse error: #{e} (raw: #{raw})")
-      rescue StandardError => e
-        log_error("Error handling message: #{e} (raw: #{raw})")
-      end
-
-      def handle_transport_error(error)
-        @connection_error = error.message
-        log_error("Transport error: #{error.message}")
-      end
-
-      def handle_transport_connect
-        log_debug("Transport connected")
-        # Send initial capabilities after connection
-        send_initial_capabilities
-      end
-
-      def handle_transport_disconnect
-        log_debug("Transport disconnected")
-      end
-
-      def send_initial_capabilities
-        log_debug("Sending client capabilities")
-
-        # If we have a session_id, we're trying to resume
-        log_debug("Attempting to resume session: #{@session_id}") if @session_id
-
-        params = {
-          protocolVersion: @protocol_version,
-          capabilities: client_capabilities,
-          clientInfo: client_info
-        }
-
-        # Include session_id if we're trying to resume
-        params[:sessionId] = @session_id if @session_id
-
-        # Use a unique request ID (not session ID since we don't have one yet)
-        request_id = SecureRandom.uuid_v7
-        send_jsonrpc_request("initialize", params: params, id: request_id)
-      end
-
-      def client_capabilities
-        {
-          # Base client capabilities can be defined here
-          # TODO
-        }
-      end
-
-      def user_agent
-        "ActionMCP-Client"
-      end
-
-      def client_info
-        {
-          name: user_agent,
-          version: ActionMCP.gem_version.to_s
-        }
-      end
-
-      def log_debug(message)
-        logger.debug("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_info(message)
-        logger.info("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_error(message)
-        logger.error("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-    end
-  end
-end

data/lib/action_mcp/client/blueprint.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Blueprints
-    #
-    # A collection that manages and provides access to URI templates (blueprints) for Model Context Protocol (MCP)
-    # resource discovery. These blueprints allow dynamic construction of resource URIs by filling in
-    # variable placeholders with specific values. The class supports lazy loading of templates when
-    # initialized with a client.
-    #
-    # Example usage:
-    #   # Eager loading
-    #   template_data = client.list_resource_templates # Returns array of URI template definitions
-    #   blueprints = Blueprint.new(template_data)
-    #
-    #   # Lazy loading
-    #   blueprints = Blueprint.new([], client)
-    #   templates = blueprints.all # Templates are loaded here
-    #
-    #   # Access a specific blueprint by pattern
-    #   file_blueprint = Blueprint.find_by_pattern("file://{path}")
-    #
-    #   # Generate a concrete URI from a blueprint with parameters
-    #   uri = Blueprint.construct("file://{path}", { path: "/logs/app.log" })
-    #
-    class Blueprint < Collection
-      # Initialize a new Blueprints collection with URI template definitions
-      #
-      # @param templates [Array<Hash>] Array of URI template definition hashes, each containing
-      #   uriTemplate, name, description, and optionally mimeType keys
-      # @param client [Object, nil] Optional client for lazy loading of templates
-      def initialize(templates, client)
-        super(templates, client)
-        self.templates = @collection_data
-        @load_method = :list_resource_templates
-      end
-
-      # Find a blueprint by its URI pattern
-      #
-      # @param pattern [String] URI template pattern to find
-      # @return [Blueprint, nil] The blueprint with the given pattern, or nil if not found
-      def find_by_pattern(pattern)
-        all.find { |blueprint| blueprint.pattern == pattern }
-      end
-
-      # Find blueprints by name
-      #
-      # @param name [String] Name of the blueprints to find
-      # @return [Array<Blueprint>] Blueprints with the given name
-      def find_by_name(name)
-        all.select { |blueprint| blueprint.name == name }
-      end
-
-      # Construct a concrete URI by applying parameters to a blueprint
-      #
-      # @param pattern [String] URI template pattern to use
-      # @param params [Hash] Parameters to substitute into the pattern
-      # @return [String] The constructed URI with parameters applied
-      # @raise [KeyError] If a required parameter is missing
-      def construct(pattern, params)
-        blueprint = find_by_pattern(pattern)
-        raise ArgumentError, "Unknown blueprint pattern: #{pattern}" unless blueprint
-
-        blueprint.construct(params)
-      end
-
-      # Check if the collection contains a blueprint with the given pattern
-      #
-      # @param pattern [String] The blueprint pattern to check for
-      # @return [Boolean] true if a blueprint with the pattern exists
-      def contains?(pattern)
-        all.any? { |blueprint| blueprint.pattern == pattern }
-      end
-
-      # Group blueprints by their base protocol
-      #
-      # @return [Hash<String, Array<Blueprint>>] Hash mapping protocols to arrays of blueprints
-      def group_by_protocol
-        all.group_by(&:protocol)
-      end
-
-      # Convert raw template data into ResourceTemplate objects
-      #
-      # @param templates [Array<Hash>] Array of template definition hashes
-      def templates=(templates)
-        @collection_data = templates.map { |template_data| ResourceTemplate.new(template_data) }
-      end
-
-      # Internal Blueprint class to represent individual URI templates
-      class ResourceTemplate
-        attr_reader :pattern, :name, :description, :mime_type, :annotations
-
-        # Initialize a new ResourceTemplate instance
-        #
-        # @param data [Hash] ResourceTemplate definition hash containing uriTemplate, name, description,
-        #   and optionally mimeType, and annotations
-        def initialize(data)
-          @pattern = data["uriTemplate"]
-          @name = data["name"]
-          @description = data["description"]
-          @mime_type = data["mimeType"]
-          @variable_pattern = /{([^}]+)}/
-          @annotations = data["annotations"] || {}
-        end
-
-        # Extract variable names from the template pattern
-        #
-        # @return [Array<String>] List of variable names in the pattern
-        def variables
-          @pattern.scan(@variable_pattern).flatten
-        end
-
-        # Get the protocol part of the URI template
-        #
-        # @return [String] The protocol (scheme) of the URI template
-        def protocol
-          @pattern.split("://").first
-        end
-
-        # Construct a concrete URI by substituting parameters into the template pattern
-        #
-        # @param params [Hash] Parameters to substitute into the pattern
-        # @return [String] The constructed URI with parameters applied
-        # @raise [KeyError] If a required parameter is missing
-        def construct(params)
-          result = @pattern.dup
-
-          variables.each do |var|
-            raise KeyError, "Missing required parameter: #{var}" unless params.key?(var.to_sym) || params.key?(var)
-
-            value = params[var.to_sym] || params[var]
-            result.gsub!("{#{var}}", value.to_s)
-          end
-
-          result
-        end
-
-        # Check if this template is compatible with a set of parameters
-        #
-        # @param params [Hash] Parameters to check
-        # @return [Boolean] true if all required variables have corresponding parameters
-        def compatible_with?(params)
-          symbolized_params = params.transform_keys(&:to_sym)
-          variables.all? { |var| symbolized_params.key?(var.to_sym) }
-        end
-
-        # Generate a hash representation of the blueprint
-        #
-        # @return [Hash] Hash containing blueprint details
-        def to_h
-          {
-            "uriTemplate" => @pattern,
-            "name" => @name,
-            "description" => @description,
-            "mimeType" => @mime_type,
-            "annotations" => @annotations
-          }
-        end
-      end
-    end
-  end
-end

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