actionmcp 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40bfac6cf4d8eff1e92f16eb58c315e3da4578ad69d10bdc83293dcfad100d5b
-  data.tar.gz: 564672c4c804b061fd53f3f905c6f092ae06b0cb596d3e4bea50adfc0fce8449
+  metadata.gz: 3e01fe9b15e57ab4450f9712dd2a38dbf355cbdc50d196a8026cbb205d3d8a07
+  data.tar.gz: 8ce8ffd799f5b9487c0bb3b78c7d7242cff31742e8cc1a79a76116e50f6cb896
 SHA512:
-  metadata.gz: ed00e79436b6a3afbbeb5cc611d4ddc0f761b71d76ec90e368aa1463c42d98aaa13fbadc73d0871d6715244b4bf3ad5f8ad3b13dc5d0aafc33399c2973885372
-  data.tar.gz: f40213363967fea34a30ec731b3048b0c54b2bb112a4f3e3f793605946a1c8f2753d9a124f15efe87f79cf53d412700393ec65d56d606b05f5601b7ad07699c9
+  metadata.gz: b044250b38fc6680fc5afa90f33dfc1082cb4ca7ec5916339e8e2a1f0b5ff64a32229968c24eeec19ec706a4341c413cc0d3546f7edee8dd9dd4ffd807427056
+  data.tar.gz: 8b98f315be3dd31d80f77d85eeddd66ab434af8077d04358928c7be3793e7ad0565d37c9042666a93810694688a45e7147b9a540ae0505b061b34b77a58cf991

data/lib/action_mcp/client.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+## TODO: Adding this so i don't forget
+module ActionMCP
+  class Client
+  end
+end

data/lib/action_mcp/configuration.rb

@@ -3,13 +3,18 @@
 module ActionMCP
   # Configuration class to hold settings for the ActionMCP server.
   class Configuration
-    attr_accessor :name, :version, :logging_enabled
+    attr_accessor :name, :version, :logging_enabled,
+                  # Right now, if enabled, the server will send a listChanged notification for tools, prompts, and resources.
+                  # We can make it more granular in the future, but for now, it's a simple boolean.
+                  :list_changed,
+                  :resources_subscribe
 
     def initialize
       # Use Rails.application values if available, or fallback to defaults.
       @name = defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:name) ? Rails.application.name : "ActionMCP"
       @version = defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:version) ? Rails.application.version.to_s.presence : "0.0.1"
       @logging_enabled = true
+      @list_changed = false
     end
   end
 end

data/lib/action_mcp/content/text.rb

@@ -8,7 +8,7 @@ module ActionMCP
 
       def initialize(text)
         super("text")
-        @text = text
+        @text = text.to_s
       end
 
       def to_h

data/lib/action_mcp/content.rb

@@ -15,9 +15,14 @@ module ActionMCP
         { type: @type }
       end
 
-      def to_json(*args)
-        to_h.to_json(*args)
+      def to_json(*)
+        MultiJson.dump(to_h, *)
       end
     end
+
+    autoload :Image
+    autoload :Text
+    autoload :Audio
+    autoload :Resource
   end
 end

data/lib/action_mcp/integer_array.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # This temporary naming extracted from MCPangea
+  # If there is a better name, please suggest it or part of ActiveModel, open a PR
+  class IntegerArray < ActiveModel::Type::Value
+    def cast(value)
+      Array(value).map(&:to_i) # Ensure all elements are integers
+    end
+  end
+end

data/lib/action_mcp/json_rpc/json_rpc_error.rb

@@ -63,7 +63,7 @@ module ActionMCP
 
       # Converts the error hash to a JSON string.
       def to_json(*_args)
-        as_json.to_json
+        MultiJson.dump(as_json, *args)
       end
     end
   end

data/lib/action_mcp/json_rpc/notification.rb

@@ -4,16 +4,15 @@ module ActionMCP
   module JsonRpc
     Notification = Data.define(:method, :params) do
       def initialize(method:, params: nil)
-        super(method: method, params: params)
+        super
       end
 
       def to_h
-        hash = {
+        {
           jsonrpc: "2.0",
-          method: method
-        }
-        hash[:params] = params if params
-        hash
+          method: method,
+          params: params
+        }.compact
       end
     end
   end

data/lib/action_mcp/json_rpc/request.rb

@@ -2,10 +2,10 @@
 
 module ActionMCP
   module JsonRpc
-    Request = Data.define(:jsonrpc, :id, :method, :params) do
+    Request = Data.define(:id, :method, :params) do
       def initialize(id:, method:, params: nil)
         validate_id(id)
-        super(id: id, method: method, params: params)
+        super
       end
 
       def to_h
@@ -17,6 +17,16 @@ module ActionMCP
         hash[:params] = params if params
         hash
       end
+
+      private
+
+      def validate_id(id)
+        unless id.is_a?(String) || id.is_a?(Numeric)
+          raise JsonRpcError.new(:invalid_params,
+                                 message: "ID must be a string or number")
+        end
+        raise JsonRpcError.new(:invalid_params, message: "ID must not be null") if id.nil?
+      end
     end
   end
 end

data/lib/action_mcp/json_rpc/response.rb

@@ -4,49 +4,29 @@ module ActionMCP
   module JsonRpc
     Response = Data.define(:id, :result, :error) do
       def initialize(id:, result: nil, error: nil)
-        processed_error = process_error(error)
-        processed_result = error ? nil : result
-        validate_result_error!(processed_result, processed_error)
-        super(id: id, result: processed_result, error: processed_error)
+        validate_presence_of_result_or_error!(result, error)
+        validate_absence_of_both_result_and_error!(result, error)
+
+        super
       end
 
       def to_h
-        hash = {
+        {
           jsonrpc: "2.0",
-          id: id
-        }
-        if error
-          hash[:error] = {
-            code: error[:code],
-            message: error[:message]
-          }
-          hash[:error][:data] = error[:data] if error[:data]
-        else
-          hash[:result] = result
-        end
-        hash
+          id: id,
+          result: result,
+          error: error
+        }.compact
       end
 
       private
 
-      def process_error(error)
-        case error
-        when Symbol
-          ErrorCodes[error]
-        when Hash
-          validate_error!(error)
-          error
-        end
-      end
-
-      def validate_error!(error)
-        raise Error, "Error code must be an integer" unless error[:code].is_a?(Integer)
-        raise Error, "Error message is required" unless error[:message].is_a?(String)
+      def validate_presence_of_result_or_error!(result, error)
+        raise ArgumentError, "Either result or error must be provided." if result.nil? && error.nil?
       end
 
-      def validate_result_error!(result, error)
-        raise Error, "Either result or error must be set" unless result || error
-        raise Error, "Cannot set both result and error" if result && error
+      def validate_absence_of_both_result_and_error!(result, error)
+        raise ArgumentError, "Both result and error cannot be provided simultaneously." if result && error
       end
     end
   end

data/lib/action_mcp/json_rpc.rb

@@ -4,7 +4,6 @@ module ActionMCP
   module JsonRpc
     extend ActiveSupport::Autoload
 
-    autoload :Base
     autoload :JsonRpcError
     autoload :Notification
     autoload :Request

data/lib/action_mcp/prompt.rb

@@ -6,6 +6,7 @@ module ActionMCP
   class Prompt
     include ActiveModel::Model
     include ActiveModel::Attributes
+    include Renderable
 
     class_attribute :_prompt_name, instance_accessor: false
     class_attribute :_description, instance_accessor: false, default: ""
@@ -72,6 +73,9 @@ module ActionMCP
 
       # Register the attribute so it's recognized by ActiveModel
       attribute arg_name, :string, default: default
+      return unless required
+
+      validates arg_name, presence: true
     end
 
     def self.arguments

data/lib/action_mcp/prompts_registry.rb

@@ -5,6 +5,25 @@ module ActionMCP
     class << self
       alias prompts items
       alias available_prompts enabled
+
+      def prompt_call(prompt_name, arguments)
+        prompt = find(prompt_name)
+        prompt = prompt.new(arguments)
+        prompt.valid?
+        if prompt.valid?
+          {
+            messages: [ {
+              role: "user",
+              content: prompt.call
+            } ]
+          }
+        else
+          {
+            content: prompt.errors.full_messages.map { |msg| Content::Text.new(msg) },
+            isError: true
+          }
+        end
+      end
     end
   end
 end

data/lib/action_mcp/registry_base.rb

@@ -2,26 +2,30 @@
 
 module ActionMCP
   class RegistryBase
+    class NotFound < StandardError; end
+
     class << self
       def items
         @items ||= {}
       end
 
-      # Register an item by unique name
-      def register(name, item_class)
+      # Register an item by unique name.
+      def register(name, klass)
         raise ArgumentError, "Name can't be blank" if name.blank?
         raise ArgumentError, "Name '#{name}' is already registered." if items.key?(name)
 
-        items[name] = { class: item_class, enabled: true }
+        items[name] = { klass: klass, enabled: true }
       end
 
-      # Fetch an item’s metadata
-      # Returns { class: <Class>, enabled: <Boolean> } or nil
-      def fetch(name)
-        items[name]
+      # Retrieve an item’s metadata by name.
+      def find(name)
+        item = items[name]
+        raise NotFound, "Item '#{name}' not found." if item.nil?
+
+        item[:klass]
       end
 
-      # Number of registered items, ignoring abstract ones.
+      # Return the number of registered items, ignoring abstract ones.
       def size
         items.values.reject { |item| abstract_item?(item) }.size
       end
@@ -34,37 +38,46 @@ module ActionMCP
         items.clear
       end
 
-      # List of currently available items, excluding abstract ones.
+      # Chainable scope: returns only enabled, non-abstract items.
       def enabled
-        items
-          .reject { |_name, item| item[:class].abstract? }
-          .select { |_name, item| item[:enabled] }
+        RegistryScope.new(items)
       end
 
-      def fetch_available_tool(name)
-        enabled[name]&.fetch(:class)
+      private
+
+      # Helper to determine if an item is abstract.
+      def abstract_item?(item)
+        klass = item[:klass]
+        klass.respond_to?(:abstract?) && klass.abstract?
       end
+    end
 
-      # Enable an item by name
-      def enable(name)
-        raise ArgumentError, "Name '#{name}' not found." unless items.key?(name)
+    # Query object for chainable registry scopes.
+    class RegistryScope
+      include Enumerable
 
-        items[name][:enabled] = true
-      end
+      # Using a Data type for items.
+      Item = Data.define(:name, :klass)
 
-      # Disable an item by name
-      def disable(name)
-        raise ArgumentError, "Name '#{name}' not found." unless items.key?(name)
+      def initialize(items)
+        @items = items.reject do |_name, item|
+          RegistryBase.send(:abstract_item?, item) || !item[:enabled]
+        end.map { |name, item| Item.new(name, item[:klass]) }
+      end
 
-        items[name][:enabled] = false
+      def each(&)
+        @items.each(&)
       end
 
-      private
+      # Returns the names (keys) of all enabled items.
+      def keys
+        @items.map(&:name)
+      end
 
-      # Helper to determine if an item is abstract.
-      def abstract_item?(item)
-        klass = item[:class]
-        klass.respond_to?(:abstract?) && klass.abstract?
+      # Chainable finder for available tools by name.
+      def find_available_tool(name)
+        item = @items.find { |i| i.name == name }
+        item&.klass
       end
     end
   end

data/lib/action_mcp/renderable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Renderable
+    def render_text(text)
+      Content::Text.new(text)
+    end
+
+    def render_audio(data, mime_type)
+      Content::Audio.new(data, mime_type)
+    end
+
+    def render_image(data, mime_type)
+      Content::Image.new(data, mime_type)
+    end
+
+    def render_resource(uri, mime_type, text: nil, blob: nil)
+      Content::Resource.new(uri, mime_type, text: text, blob: blob)
+    end
+
+    def render_error(errors)
+      {
+        isError: true,
+        content: errors.map { |error| render_text(error) }
+      }
+    end
+  end
+end

data/lib/action_mcp/resource.rb

@@ -13,8 +13,8 @@ module ActionMCP
     end
 
     # Convert the resource to a JSON string.
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      MultiJson.dump(to_h, *)
     end
   end
 end

data/lib/action_mcp/resources_bank.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# frozen_string_literal: true
-
 module ActionMCP
   module ResourcesBank
     @resources = {}    # { uri => content_object }

data/lib/action_mcp/server.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# TODO: move all server related code here before version 1.0.0
+module ActionMCP
+  module Server
+  end
+end

data/lib/action_mcp/string_array.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class StringArray < ActiveModel::Type::Value
+    def cast(value)
+      Array(value).map(&:to_s) # Ensure all elements are strings
+    end
+  end
+end

data/lib/action_mcp/tool.rb

@@ -1,18 +1,30 @@
-# lib/action_mcp/tool.rb
 # frozen_string_literal: true
 
 module ActionMCP
+  # Base class for defining tools.
+  #
+  # Provides a DSL for specifying metadata, properties, and nested collection schemas.
+  # Tools are registered automatically in the ToolsRegistry unless marked as abstract.
   class Tool
     include ActiveModel::Model
     include ActiveModel::Attributes
+    include Renderable
 
+    # --------------------------------------------------------------------------
+    # Class Attributes for Tool Metadata and Schema
+    # --------------------------------------------------------------------------
     class_attribute :_tool_name, instance_accessor: false
     class_attribute :_description, instance_accessor: false, default: ""
     class_attribute :_schema_properties, instance_accessor: false, default: {}
     class_attribute :_required_properties, instance_accessor: false, default: []
     class_attribute :abstract_tool, instance_accessor: false, default: false
 
-    # Register each non-abstract subclass in ToolsRegistry
+    # --------------------------------------------------------------------------
+    # Subclass Registration
+    # --------------------------------------------------------------------------
+    # Automatically registers non-abstract subclasses in the ToolsRegistry.
+    #
+    # @param subclass [Class] the subclass inheriting from Tool.
     def self.inherited(subclass)
       super
       return if subclass == Tool
@@ -23,19 +35,27 @@ module ActionMCP
       ToolsRegistry.register(subclass.tool_name, subclass)
     end
 
-    # Mark this tool as abstract so it won’t be available for use.
+    # Marks this tool as abstract so that it won’t be available for use.
+    # If the tool is registered in ToolsRegistry, it is unregistered.
     def self.abstract!
       self.abstract_tool = true
       ToolsRegistry.unregister(tool_name) if ToolsRegistry.items.key?(tool_name)
     end
 
+    # Returns whether this tool is abstract.
+    #
+    # @return [Boolean] true if abstract, false otherwise.
     def self.abstract?
       abstract_tool
     end
 
-    # ---------------------------------------------------
-    # Tool Name & Description
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Tool Name and Description DSL
+    # --------------------------------------------------------------------------
+    # Sets or retrieves the tool's name.
+    #
+    # @param name [String, nil] Optional. The name to set for the tool.
+    # @return [String] The current tool name.
     def self.tool_name(name = nil)
       if name
         self._tool_name = name
@@ -44,10 +64,17 @@ module ActionMCP
       end
     end
 
+    # Returns a default tool name based on the class name.
+    #
+    # @return [String] The default tool name.
     def self.default_tool_name
       name.demodulize.underscore.dasherize.sub(/-tool$/, "")
     end
 
+    # Sets or retrieves the tool's description.
+    #
+    # @param text [String, nil] Optional. The description text to set.
+    # @return [String] The current description.
     def self.description(text = nil)
       if text
         self._description = text
@@ -56,86 +83,71 @@ module ActionMCP
       end
     end
 
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
     # Property DSL (Direct Declaration)
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Defines a property for the tool.
+    #
+    # This method builds a JSON Schema definition for the property, registers it
+    # in the tool's schema, and creates an ActiveModel attribute for it.
+    #
+    # @param prop_name [Symbol, String] The property name.
+    # @param type [String] The JSON Schema type (default: "string").
+    # @param description [String, nil] Optional description for the property.
+    # @param required [Boolean] Whether the property is required (default: false).
+    # @param default [Object, nil] The default value for the property.
+    # @param opts [Hash] Additional options for the JSON Schema.
     def self.property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
-      # Build JSON Schema definition for the property.
+      # Build the JSON Schema definition.
       prop_definition = { type: type }
       prop_definition[:description] = description if description && !description.empty?
       prop_definition.merge!(opts) if opts.any?
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => prop_definition)
-      self._required_properties = _required_properties.dup
-      _required_properties << prop_name.to_s if required
-
-      # Map our DSL type to an ActiveModel attribute type.
-      am_type = case type.to_s
-      when "number" then :float
-      when "integer" then :integer
-      when "array"   then :string
-      else
-                  :string
+      self._required_properties = _required_properties.dup.tap do |req|
+        req << prop_name.to_s if required
       end
-      attribute prop_name, am_type, default: default
+
+      # Map the JSON Schema type to an ActiveModel attribute type.
+      attribute prop_name, map_json_type_to_active_model_type(type), default: default
+      validates prop_name, presence: true, if: -> { required }
+
+      return unless %w[number integer].include?(type)
+
+      validates prop_name, numericality: true
     end
 
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
     # Collection DSL
-    # ---------------------------------------------------
-    # Supports two forms:
-    #
-    # 1. Without a block:
-    #    collection :args, type: "string", description: "Command arguments"
+    # --------------------------------------------------------------------------
+    # Defines a collection property for the tool.
     #
-    # 2. With a block (defining a nested object):
-    #    collection :files, description: "List of Files" do
-    #      property :file, required: true, description: 'file uri'
-    #      property :checksum, required: true, description: 'checksum to verify'
-    #    end
-    def self.collection(prop_name, type: nil, description: nil, required: false, default: nil, **_opts, &block)
-      if block_given?
-        # Build nested schema for an object.
-        nested_schema = { type: "object", properties: {}, required: [] }
-        dsl = CollectionDSL.new(nested_schema)
-        dsl.instance_eval(&block)
-        collection_definition = { type: "array", description: description, items: nested_schema }
-      else
-        raise ArgumentError, "Type is required for a collection without a block" if type.nil?
+    # @param prop_name [Symbol, String] The collection property name.
+    # @param type [String] The type for collection items.
+    # @param description [String, nil] Optional description for the collection.
+    # @param required [Boolean] Whether the collection is required (default: false).
+    # @param default [Array, nil] The default value for the collection.
+    def self.collection(prop_name, type:, description: nil, required: false, default: [])
+      raise ArgumentError, "Type is required for a collection" if type.nil?
 
-        collection_definition = { type: "array", description: description, items: { type: type } }
-      end
+      collection_definition = { type: "array", description: description, items: { type: type } }
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => collection_definition)
-      self._required_properties = _required_properties.dup
-      _required_properties << prop_name.to_s if required
-
-      # Register the property as an attribute.
-      # (Mapping for a collection can be customized; here we use :string to mimic previous behavior.)
-      attribute prop_name, :string, default: default
-    end
-
-    # DSL for building a nested schema within a collection block.
-    class CollectionDSL
-      attr_reader :schema
-
-      def initialize(schema)
-        @schema = schema
+      self._required_properties = _required_properties.dup.tap do |req|
+        req << prop_name.to_s if required
       end
 
-      def property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
-        prop_definition = { type: type }
-        prop_definition[:description] = description if description && !description.empty?
-        prop_definition.merge!(opts) if opts.any?
-
-        @schema[:properties][prop_name.to_s] = prop_definition
-        @schema[:required] << prop_name.to_s if required
-      end
+      type = map_json_type_to_active_model_type("array_#{type}")
+      attribute prop_name, type, default: default
+      validates prop_name, presence: true, if: -> { required }
     end
 
-    # ---------------------------------------------------
-    # Convert Tool Definition to Hash
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Tool Definition Serialization
+    # --------------------------------------------------------------------------
+    # Returns a hash representation of the tool definition including its JSON Schema.
+    #
+    # @return [Hash] The tool definition.
     def self.to_h
       schema = { type: "object", properties: _schema_properties }
       schema[:required] = _required_properties if _required_properties.any?
@@ -145,5 +157,40 @@ module ActionMCP
         inputSchema: schema
       }.compact
     end
+
+    # --------------------------------------------------------------------------
+    # Instance Methods
+    # --------------------------------------------------------------------------
+    # Abstract method to perform the tool's action.
+    #
+    # Subclasses must implement this method.
+    #
+    # @raise [NotImplementedError] Always raised if not implemented in a subclass.
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+      # Default implementation (no-op)
+      # In a real subclass, you might do:
+      #   def call
+      #     # Perform logic, e.g. analyze code, etc.
+      #     # Array of Content objects is expected as return value
+      #   end
+    end
+
+    private
+
+    # Maps a JSON Schema type to an ActiveModel attribute type.
+    #
+    # @param type [String] The JSON Schema type.
+    # @return [Symbol] The corresponding ActiveModel attribute type.
+    def self.map_json_type_to_active_model_type(type)
+      case type.to_s
+      when "number" then  :float # JSON Schema "number" is a float in Ruby, the spec doesn't have an integer type yet.
+      when "array_number" then :integer_array
+      when "array_integer" then :string_array
+      when "array_string" then :string_array
+      else                :string
+      end
+    end
+    private_class_method :map_json_type_to_active_model_type
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -1,12 +1,24 @@
 # frozen_string_literal: true
 
-# frozen_string_literal: true
-
 module ActionMCP
   class ToolsRegistry < RegistryBase
     class << self
       alias tools items
       alias available_tools enabled
+
+      def tool_call(tool_name, arguments, _metadata = {})
+        tool = find(tool_name)
+        tool = tool.new(arguments)
+        tool.validate
+        if tool.valid?
+          { content: [ tool.call ] }
+        else
+          {
+            content: tool.errors.full_messages.map { |msg| Content::Text.new(msg) },
+            isError: true
+          }
+        end
+      end
     end
   end
 end

data/lib/action_mcp/transport.rb

@@ -3,27 +3,38 @@
 module ActionMCP
   class Transport
     HEARTBEAT_INTERVAL = 15 # seconds
+    attr_reader :initialized
 
+    # Initializes a new Transport.
+    #
+    # @param output_io [IO] An IO-like object where events will be written.
     def initialize(output_io)
       # output_io can be any IO-like object where we write events.
       @output = output_io
       @output.sync = true
+      @initialized = false
+      @client_capabilities = {}
+      @client_info = {}
+      @protocol_version = ""
     end
 
     # Sends the capabilities JSON-RPC notification.
     #
     # @param request_id [String, Integer] The request identifier.
-    def send_capabilities(request_id)
+    def send_capabilities(request_id, params = {})
+      @protocol_version = params["protocolVersion"]
+      @client_info = params["clientInfo"]
+      @client_capabilities = params["capabilities"]
+      Rails.logger.info("Client capabilities stored: #{@client_capabilities}")
       capabilities = {}
 
       # Only include each capability if the corresponding registry is non-empty.
-      capabilities[:tools] = { listChanged: true } if ActionMCP::ToolsRegistry.available_tools.any?
-
-      capabilities[:prompts] = { listChanged: true } if ActionMCP::PromptsRegistry.available_prompts.any?
-
-      capabilities[:resources] = { listChanged: true } if ActionMCP::ResourcesBank.all_resources.any?
-
-      # Add logging capability only if enabled by configuration.
+      capabilities[:tools] = { listChanged: ActionMCP.configuration.list_changed } if ToolsRegistry.available_tools.any?
+      if PromptsRegistry.available_prompts.any?
+        capabilities[:prompts] =
+          { listChanged: ActionMCP.configuration.list_changed }
+      end
+      capabilities[:resources] = { subscribe: ActionMCP.configuration.list_changed } if ResourcesBank.all_resources.any?
       capabilities[:logging] = {} if ActionMCP.configuration.logging_enabled
 
       payload = {
@@ -37,25 +48,22 @@ module ActionMCP
       send_jsonrpc_response(request_id, result: payload)
     end
 
-    # Sends the tools list JSON-RPC notification.
-    #
-    # @param request_id [String, Integer] The request identifier.
-    def send_tools_list(request_id)
-      tools = format_registry_items(ActionMCP::ToolsRegistry.available_tools)
-      send_jsonrpc_response(request_id, result: { tools: tools })
+    def initialized!
+      @initialized = true
+      Rails.logger.info("Transport initialized.")
     end
 
     # Sends the resources list JSON-RPC response.
     #
     # @param request_id [String, Integer] The request identifier.
     def send_resources_list(request_id)
-      resources = ActionMCP::ResourcesBank.all_resources # fetch all resources
+      resources = ResourcesBank.all_resources # fetch all resources
       result_data = { "resources" => resources }
       send_jsonrpc_response(request_id, result: result_data)
       Rails.logger.info("resources/list: Returned #{resources.size} resources.")
     rescue StandardError => e
       Rails.logger.error("resources/list failed: #{e.message}")
-      error_obj = JsonRpcError.new(
+      error_obj = JsonRpc::JsonRpcError.new(
         :internal_error,
         message: "Failed to list resources: #{e.message}"
       ).as_json
@@ -66,13 +74,13 @@ module ActionMCP
     #
     # @param request_id [String, Integer] The request identifier.
     def send_resource_templates_list(request_id)
-      templates = ActionMCP::ResourcesBank.all_templates # get all resource templates
+      templates = ResourcesBank.all_templates # get all resource templates
       result_data = { "resourceTemplates" => templates }
       send_jsonrpc_response(request_id, result: result_data)
       Rails.logger.info("resources/templates/list: Returned #{templates.size} resource templates.")
     rescue StandardError => e
       Rails.logger.error("resources/templates/list failed: #{e.message}")
-      error_obj = JsonRpcError.new(
+      error_obj = JsonRpc::JsonRpcError.new(
         :internal_error,
         message: "Failed to list resource templates: #{e.message}"
       ).as_json
@@ -87,7 +95,7 @@ module ActionMCP
       uri = params&.fetch("uri", nil)
       if uri.nil? || uri.empty?
         Rails.logger.error("resources/read: 'uri' parameter is missing")
-        error_obj = JsonRpcError.new(
+        error_obj = JsonRpc::JsonRpcError.new(
           :invalid_params,
           message: "Missing 'uri' parameter for resources/read"
         ).as_json
@@ -95,10 +103,10 @@ module ActionMCP
       end
 
       begin
-        content = ActionMCP::ResourcesBank.read(uri) # Expecting an instance of an ActionMCP::Content subclass
+        content = ResourcesBank.read(uri) # Expecting an instance of an ActionMCP::Content subclass
         if content.nil?
           Rails.logger.error("resources/read: Resource not found for URI #{uri}")
-          error_obj = JsonRpcError.new(
+          error_obj = JsonRpc::JsonRpcError.new(
             :invalid_params,
             message: "Resource not found: #{uri}"
           ).as_json
@@ -114,7 +122,7 @@ module ActionMCP
         Rails.logger.info(log_msg)
       rescue StandardError => e
         Rails.logger.error("resources/read: Error reading #{uri} - #{e.message}")
-        error_obj = JsonRpcError.new(
+        error_obj = JsonRpc::JsonRpcError.new(
           :internal_error,
           message: "Failed to read resource: #{e.message}"
         ).as_json
@@ -122,73 +130,47 @@ module ActionMCP
       end
     end
 
-    # Sends a call to a tool. Currently logs the call details.
+    # Sends the tools list JSON-RPC notification.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_tools_list(request_id)
+      tools = format_registry_items(ToolsRegistry.available_tools)
+      send_jsonrpc_response(request_id, result: { tools: tools })
+    end
+
+    # Sends a call to a tool.
     #
     # @param request_id [String, Integer] The request identifier.
     # @param tool_name [String] The name of the tool.
-    # @param params [Hash] The parameters for the tool.
-    def send_tools_call(request_id, tool_name, params)
-      ActionMCP::ToolsRegistry.fetch_available_tool(tool_name.to_s)
-      Rails.logger.info("Sending tool call: #{tool_name} with params: #{params}")
-      # TODO: Implement tool call handling and response if needed.
-    rescue StandardError => e
-      Rails.logger.error("tools/call: Failed to call tool #{tool_name} - #{e.message}")
-      error_obj = JsonRpcError.new(
-        :internal_error,
-        message: "Failed to call tool #{tool_name}: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
+    # @param arguments [Hash] The arguments for the tool.
+    # @param _meta [Hash] Additional metadata.
+    def send_tools_call(request_id, tool_name, arguments, _meta = {})
+      result = ToolsRegistry.tool_call(tool_name, arguments, _meta)
+      send_jsonrpc_response(request_id, result:)
+    rescue RegistryBase::NotFound
+      send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(:method_not_found,
+                                                                         message: "Tool not found: #{tool_name}").as_json)
     end
 
     # Sends the prompts list JSON-RPC notification.
     #
     # @param request_id [String, Integer] The request identifier.
     def send_prompts_list(request_id)
-      prompts = format_registry_items(ActionMCP::PromptsRegistry.available_prompts)
+      prompts = format_registry_items(PromptsRegistry.available_prompts)
       send_jsonrpc_response(request_id, result: { prompts: prompts })
-    rescue StandardError => e
-      Rails.logger.error("prompts/list failed: #{e.message}")
-      error_obj = JsonRpcError.new(
-        :internal_error,
-        message: "Failed to list prompts: #{e.message}"
-      ).as_json
-      send_jsonrpc_response(request_id, error: error_obj)
     end
 
-    def send_prompts_get(request_id, params)
-      prompt_name = params&.fetch("name", nil)
-      if prompt_name.nil? || prompt_name.strip.empty?
-        Rails.logger.error("prompts/get: 'name' parameter is missing")
-        error_obj = JsonRpcError.new(
-          :invalid_params,
-          message: "Missing 'name' parameter for prompts/get"
-        ).as_json
-        return send_jsonrpc_response(request_id, error: error_obj)
-      end
-
-      begin
-        # Assume a method similar to fetch_available_tool exists for prompts.
-        prompt = ActionMCP::PromptsRegistry.fetch_available_prompt(prompt_name.to_s)
-        if prompt.nil?
-          Rails.logger.error("prompts/get: Prompt not found for name #{prompt_name}")
-          error_obj = JsonRpcError.new(
-            :invalid_params,
-            message: "Prompt not found: #{prompt_name}"
-          ).as_json
-          return send_jsonrpc_response(request_id, error: error_obj)
-        end
+    def send_prompts_get(request_id, prompt_name, params)
+      send_jsonrpc_response(request_id, result: PromptsRegistry.prompt_call(prompt_name.to_s, params))
+    rescue RegistryBase::NotFound
+      send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(:method_not_found,
+                                                                         message: "Prompt not found: #{prompt_name}").as_json)
+    end
 
-        result_data = { "prompt" => prompt.to_h }
-        send_jsonrpc_response(request_id, result: result_data)
-        Rails.logger.info("prompts/get: Returned prompt #{prompt_name}")
-      rescue StandardError => e
-        Rails.logger.error("prompts/get: Error retrieving prompt #{prompt_name} - #{e.message}")
-        error_obj = JsonRpcError.new(
-          :internal_error,
-          message: "Failed to get prompt: #{e.message}"
-        ).as_json
-        send_jsonrpc_response(request_id, error: error_obj)
-      end
+    # Sends the roots list JSON-RPC request.
+    # TODO: test it
+    def send_roots_list
+      send_jsonrpc_request("roots/list")
     end
 
     # Sends a JSON-RPC pong response.
@@ -199,6 +181,19 @@ module ActionMCP
       send_jsonrpc_response(request_id, result: {})
     end
 
+    def send_ping
+      send_jsonrpc_request("ping")
+    end
+
+    # Sends a JSON-RPC request.
+    # @param method [String] The JSON-RPC method.
+    # @param params [Hash] The parameters for the method.
+    # @param id [String] The request identifier.
+    def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
+      request = JsonRpc::Request.new(id: id, method: method, params: params)
+      write_message(request.to_json)
+    end
+
     # Sends a JSON-RPC response.
     #
     # @param request_id [String, Integer] The request identifier.
@@ -213,7 +208,7 @@ module ActionMCP
     #
     # @param method [String] The JSON-RPC method.
     # @param params [Hash] The parameters for the method.
-    def send_jsonrpc_notification(method, params = {})
+    def send_jsonrpc_notification(method, params = nil)
       notification = JsonRpc::Notification.new(method: method, params: params)
       write_message(notification.to_json)
     end
@@ -225,17 +220,19 @@ module ActionMCP
     # @param registry [Hash] The registry containing tool or prompt definitions.
     # @return [Array<Hash>] The formatted registry items.
     def format_registry_items(registry)
-      registry.map { |_, item| item[:class].to_h }
+      registry.map { |item| item.klass.to_h }
     end
 
     # Writes a message to the output IO.
     #
     # @param data [String] The data to write.
     def write_message(data)
-      Rails.logger.debug("Response Sent: #{data}")
-      @output.write("#{data}\n")
-    rescue IOError => e
-      Rails.logger.error("Failed to write message: #{e.message}")
+      Timeout.timeout(5) do # 5 second timeout
+        @output.write("#{data}\n")
+      end
+    rescue Timeout::Error
+      Rails.logger.error("Write operation timed out")
+      # Handle timeout appropriately
     end
   end
 end

data/lib/action_mcp/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActionMCP
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
   # Returns the currently loaded version of Active MCP as a +Gem::Version+.
   def self.version
     gem_version

data/lib/action_mcp.rb

@@ -4,7 +4,10 @@ require "rails"
 require "active_support"
 require "active_model"
 require "action_mcp/version"
+require "multi_json"
 require "action_mcp/railtie" if defined?(Rails)
+require_relative "action_mcp/integer_array"
+require_relative "action_mcp/string_array"
 
 ActiveSupport::Inflector.inflections(:en) do |inflect|
   inflect.acronym "MCP"
@@ -20,6 +23,10 @@ module ActionMCP
   autoload :Tool
   autoload :Prompt
   autoload :JsonRpc
+  autoload :Transport
+  autoload :Content
+  autoload :Renderable
+
   eager_autoload do
     autoload :Configuration
   end
@@ -50,4 +57,7 @@ module ActionMCP
   def available_prompts
     PromptsRegistry.available_prompts
   end
+
+  ActiveModel::Type.register(:string_array, StringArray)
+  ActiveModel::Type.register(:integer_array, IntegerArray)
 end

data/lib/generators/action_mcp/install/install_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Generators
     class InstallGenerator < Rails::Generators::Base

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 bindir: exe
 cert_chain: []
-date: 2025-02-14 00:00:00.000000000 Z
+date: 2025-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -65,6 +65,7 @@ files:
 - Rakefile
 - exe/action_mcp_stdio
 - lib/action_mcp.rb
+- lib/action_mcp/client.rb
 - lib/action_mcp/configuration.rb
 - lib/action_mcp/content.rb
 - lib/action_mcp/content/audio.rb
@@ -72,8 +73,8 @@ files:
 - lib/action_mcp/content/resource.rb
 - lib/action_mcp/content/text.rb
 - lib/action_mcp/gem_version.rb
+- lib/action_mcp/integer_array.rb
 - lib/action_mcp/json_rpc.rb
-- lib/action_mcp/json_rpc/base.rb
 - lib/action_mcp/json_rpc/json_rpc_error.rb
 - lib/action_mcp/json_rpc/notification.rb
 - lib/action_mcp/json_rpc/request.rb
@@ -82,8 +83,11 @@ files:
 - lib/action_mcp/prompts_registry.rb
 - lib/action_mcp/railtie.rb
 - lib/action_mcp/registry_base.rb
+- lib/action_mcp/renderable.rb
 - lib/action_mcp/resource.rb
 - lib/action_mcp/resources_bank.rb
+- lib/action_mcp/server.rb
+- lib/action_mcp/string_array.rb
 - lib/action_mcp/tool.rb
 - lib/action_mcp/tools_registry.rb
 - lib/action_mcp/transport.rb
@@ -103,6 +107,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/seuros/action_mcp
   source_code_uri: https://github.com/seuros/action_mcp
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib

data/lib/action_mcp/json_rpc/base.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module JsonRpc
-    private
-
-    def validate_id(id)
-      raise Error, "ID must be a string or number" unless id.is_a?(String) || id.is_a?(Numeric)
-      raise Error, "ID must not be null" if id.nil?
-    end
-  end
-end