actionmcp 0.102.0 → 0.103.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d01a1c6af1a49f9992d61bfe0e0bb6aa6ab8429dbdd21e977c27506fd21cb90e
-  data.tar.gz: 650eac8eb9711cafffee1b5e27d45873f8a28b3a9c07d27ca91d4bada3c72436
+  metadata.gz: 0b98e5c438f85bfe710dbe07d1b9cc2a12d7347b4fc200c66a0492f380615599
+  data.tar.gz: 921adb81f040f14533248ce6c52b142a85d8445299e19a83501171b344601c11
 SHA512:
-  metadata.gz: 750107898a375f73d7055cb1b346971e5f1bdfe5ca82d8839a280a67c03a396970e9e7919dac5146e456cc0a49ffbe6013bfac0ec8ded7da515bd3691147a18d
-  data.tar.gz: a1701f0a82a4320896731bc33f7db4968524133e5b6f407ac0174fed70165a36d36079e6f6f179d149305bbbbfb4977320f63d7e36afc78bc16d2f012911dac5
+  metadata.gz: 9aee10304fc9e926a34805c760545adb565b5a19dd7fe59e445ed938d82b2e92e9e7d8e5762db2a5dfc12a844fdbbfb9b84ed7a15f2879703fe7c83b6eb29ec2
+  data.tar.gz: 4b35888139f56c100415e64f495e61efcd43eac2652bf99b1dfbf1ae269fb317d19fad9f0a1ee99b8a19d1e2a36dd3d1818d4ff76a67456f7e9c7edc21457fb7

data/README.md

@@ -46,6 +46,14 @@ In short, ActionMCP helps you build an MCP server (the component that exposes ca
 
 > **Client connections:** The client part of ActionMCP is meant to connect to remote MCP servers only. Connecting to local processes (such as via STDIO) is not supported.
 
+## Requirements
+
+- **Ruby**: 3.4.8+ or 4.0.0+
+- **Rails**: 8.1.1+
+- **Database**: PostgreSQL, MySQL, or SQLite3
+
+ActionMCP is tested against Ruby 3.4.8 and 4.0.0 with Rails 8.1.1+.
+
 ## Installation
 
 To start using ActionMCP, add it to your project:
@@ -179,7 +187,7 @@ For tools that perform sensitive operations (file system access, database modifi
 class FileSystemTool < ApplicationMCPTool
   tool_name "read_file"
   description "Read contents of a file"
-  
+
   # Require explicit consent before execution
   requires_consent!
 
@@ -392,7 +400,7 @@ ActionMCP provides comprehensive documentation across multiple specialized guide
 - **[Installation & Configuration](README.md#installation)** - Initial setup, database migrations, and basic configuration
 - **[Authentication with Gateway](README.md#authentication-with-gateway)** - User authentication and authorization patterns
 
-### Component Development  
+### Component Development
 - **[📋 TOOLS.MD](TOOLS.MD)** - Complete guide to developing MCP tools
   - Generator usage and best practices
   - Property definitions, validation, and consent management
@@ -1042,7 +1050,7 @@ class MyTool < ApplicationMCPTool
       report_error("Clear error message for the LLM")
       return
     end
-    
+
     # Normal processing
     render(text: "Success message")
   end

data/lib/action_mcp/test_helper/session_store_assertions.rb

@@ -51,64 +51,6 @@ module ActionMCP
                      message || "Expected #{expected} session operations#{type_desc}, got #{actual}"
       end
 
-      # Client session store assertions
-      def assert_client_session_saved(session_id, message = nil)
-        assert client_session_store.session_saved?(session_id),
-               message || "Expected client session #{session_id} to have been saved"
-      end
-
-      def assert_client_session_not_saved(session_id, message = nil)
-        assert_not client_session_store.session_saved?(session_id),
-                   message || "Expected client session #{session_id} not to have been saved"
-      end
-
-      def assert_client_session_loaded(session_id, message = nil)
-        assert client_session_store.session_loaded?(session_id),
-               message || "Expected client session #{session_id} to have been loaded"
-      end
-
-      def assert_client_session_not_loaded(session_id, message = nil)
-        assert_not client_session_store.session_loaded?(session_id),
-                   message || "Expected client session #{session_id} not to have been loaded"
-      end
-
-      def assert_client_session_updated(session_id, message = nil)
-        assert client_session_store.session_updated?(session_id),
-               message || "Expected client session #{session_id} to have been updated"
-      end
-
-      def assert_client_session_not_updated(session_id, message = nil)
-        assert_not client_session_store.session_updated?(session_id),
-                   message || "Expected client session #{session_id} not to have been updated"
-      end
-
-      def assert_client_session_deleted(session_id, message = nil)
-        assert client_session_store.session_deleted?(session_id),
-               message || "Expected client session #{session_id} to have been deleted"
-      end
-
-      def assert_client_session_not_deleted(session_id, message = nil)
-        assert_not client_session_store.session_deleted?(session_id),
-                   message || "Expected client session #{session_id} not to have been deleted"
-      end
-
-      def assert_client_session_operation_count(expected, type = nil, message = nil)
-        actual = client_session_store.operation_count(type)
-        type_desc = type ? " of type #{type}" : ""
-        assert_equal expected, actual,
-                     message || "Expected #{expected} client session operations#{type_desc}, got #{actual}"
-      end
-
-      def assert_client_session_data_includes(session_id, expected_data, message = nil)
-        saved_data = client_session_store.last_saved_data(session_id)
-        assert saved_data, "No saved data found for session #{session_id}"
-
-        expected_data.each do |key, value|
-          assert_equal value, saved_data[key],
-                       message || "Expected session #{session_id} data to include #{key}: #{value}"
-        end
-      end
-
       private
 
       def server_session_store
@@ -117,18 +59,6 @@ module ActionMCP
 
         store
       end
-
-      def client_session_store
-        # This would need to be set by the test or could use a thread-local variable
-        # For now, we'll assume it's available as an instance variable
-        store = @client_session_store || Thread.current[:test_client_session_store]
-        unless store
-          raise "Client session store not set. Set @client_session_store or Thread.current[:test_client_session_store]"
-        end
-        raise "Client session store is not a TestSessionStore" unless store.is_a?(ActionMCP::Client::TestSessionStore)
-
-        store
-      end
     end
   end
 end

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.102.0"
+  VERSION = "0.103.0"
 
   class << self
     alias version gem_version

data/lib/action_mcp.rb

@@ -29,7 +29,6 @@ end.setup
 
 module ActionMCP
   require_relative "action_mcp/version"
-  require_relative "action_mcp/client"
 
   # Error raised when structured content doesn't match the declared output_schema
   class StructuredContentValidationError < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.102.0
+  version: 0.103.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -173,31 +173,6 @@ files:
 - lib/action_mcp/base_response.rb
 - lib/action_mcp/callbacks.rb
 - lib/action_mcp/capability.rb
-- lib/action_mcp/client.rb
-- lib/action_mcp/client/active_record_session_store.rb
-- lib/action_mcp/client/base.rb
-- lib/action_mcp/client/blueprint.rb
-- lib/action_mcp/client/catalog.rb
-- lib/action_mcp/client/collection.rb
-- lib/action_mcp/client/elicitation.rb
-- lib/action_mcp/client/json_rpc_handler.rb
-- lib/action_mcp/client/logging.rb
-- lib/action_mcp/client/messaging.rb
-- lib/action_mcp/client/prompt_book.rb
-- lib/action_mcp/client/prompts.rb
-- lib/action_mcp/client/request_timeouts.rb
-- lib/action_mcp/client/resources.rb
-- lib/action_mcp/client/roots.rb
-- lib/action_mcp/client/server.rb
-- lib/action_mcp/client/session_store.rb
-- lib/action_mcp/client/session_store_factory.rb
-- lib/action_mcp/client/streamable_client.rb
-- lib/action_mcp/client/streamable_http_transport.rb
-- lib/action_mcp/client/test_session_store.rb
-- lib/action_mcp/client/toolbox.rb
-- lib/action_mcp/client/tools.rb
-- lib/action_mcp/client/transport.rb
-- lib/action_mcp/client/volatile_session_store.rb
 - lib/action_mcp/configuration.rb
 - lib/action_mcp/console_detector.rb
 - lib/action_mcp/content.rb
@@ -327,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.1
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Lightweight Model Context Protocol (MCP) server toolkit for Ruby/Rails
 test_files: []

data/lib/action_mcp/client/active_record_session_store.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # ActiveRecord-backed session store for production
-    class ActiveRecordSessionStore
-      include SessionStore
-
-      def load_session(session_id)
-        session = ActionMCP::Session.find_by(id: session_id)
-        return nil unless session
-
-        {
-          id: session.id,
-          protocol_version: session.protocol_version,
-          client_info: session.client_info,
-          client_capabilities: session.client_capabilities,
-          server_info: session.server_info,
-          server_capabilities: session.server_capabilities,
-          created_at: session.created_at,
-          updated_at: session.updated_at
-        }
-      end
-
-      def save_session(session_id, session_data)
-        session = ActionMCP::Session.find_or_initialize_by(id: session_id)
-
-        # Only assign attributes that exist in the database
-        attributes = {}
-        attributes[:protocol_version] = session_data[:protocol_version] if session_data.key?(:protocol_version)
-        attributes[:client_info] = session_data[:client_info] if session_data.key?(:client_info)
-        attributes[:client_capabilities] = session_data[:client_capabilities] if session_data.key?(:client_capabilities)
-        attributes[:server_info] = session_data[:server_info] if session_data.key?(:server_info)
-        attributes[:server_capabilities] = session_data[:server_capabilities] if session_data.key?(:server_capabilities)
-
-        # Store any extra data in a jsonb column if available
-        # For now, we'll skip last_event_id and session_data as they don't exist in the DB
-
-        session.assign_attributes(attributes)
-        session.save!
-        session_data
-      end
-
-      def delete_session(session_id)
-        ActionMCP::Session.find_by(id: session_id)&.destroy
-      end
-
-      def session_exists?(session_id)
-        ActionMCP::Session.exists?(id: session_id)
-      end
-
-      def cleanup_expired_sessions(older_than: 24.hours.ago)
-        ActionMCP::Session.where("updated_at < ?", older_than).delete_all
-      end
-    end
-  end
-end

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