actionmcp 0.2.0 → 0.2.4

data/lib/action_mcp/content.rb

@@ -1,28 +1,33 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Module for managing content within ActionMCP.
   module Content
-    extend ActiveSupport::Autoload
     # Base class for MCP content items.
     class Base
+      # @return [Symbol] The type of content.
       attr_reader :type
 
+      # Initializes a new content item.
+      #
+      # @param type [Symbol] The type of content.
       def initialize(type)
         @type = type
       end
 
+      # Returns a hash representation of the content.
+      #
+      # @return [Hash] The hash representation.
       def to_h
         { type: @type }
       end
 
+      # Returns a JSON representation of the content.
+      #
+      # @return [String] The JSON representation.
       def to_json(*)
         MultiJson.dump(to_h, *)
       end
     end
-
-    autoload :Image
-    autoload :Text
-    autoload :Audio
-    autoload :Resource
   end
 end

data/lib/action_mcp/engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails"
+require "active_model/railtie"
+
+module ActionMCP
+  # Engine for integrating ActionMCP with Rails applications.
+  class Engine < ::Rails::Engine
+    isolate_namespace ActionMCP
+
+    ActiveSupport::Inflector.inflections(:en) do |inflect|
+      inflect.acronym "SSE"
+      inflect.acronym "MCP"
+    end
+    # Provide a configuration namespace for ActionMCP
+    config.action_mcp = ActiveSupport::OrderedOptions.new
+
+    initializer "action_mcp.configure" do |app|
+      options = app.config.action_mcp.to_h.symbolize_keys
+
+      # Override the default configuration if specified in the Rails app.
+      ActionMCP.configuration.name            = options[:name] if options.key?(:name)
+      ActionMCP.configuration.version         = options[:version] if options.key?(:version)
+      ActionMCP.configuration.logging_enabled = options.fetch(:logging_enabled, true)
+    end
+
+    # Initialize the ActionMCP logger.
+    initializer "action_mcp.logger" do
+      ActiveSupport.on_load(:action_mcp) do
+        self.logger = ::Rails.logger
+      end
+    end
+  end
+end

data/lib/action_mcp/gem_version.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
-
 module ActionMCP
   # Returns the currently loaded version of Active MCP as a +Gem::Version+.
+  #
+  # @return [Gem::Version] the currently loaded version of Active MCP
   def self.gem_version
     Gem::Version.new VERSION
   end

data/lib/action_mcp/integer_array.rb

@@ -3,7 +3,13 @@
 module ActionMCP
   # This temporary naming extracted from MCPangea
   # If there is a better name, please suggest it or part of ActiveModel, open a PR
+  #
+  # Custom type for handling arrays of integers in ActiveModel.
   class IntegerArray < ActiveModel::Type::Value
+    # Casts the given value to an array of integers.
+    #
+    # @param value [Object] The value to cast.
+    # @return [Array<Integer>] The array of integers.
     def cast(value)
       Array(value).map(&:to_i) # Ensure all elements are integers
     end

data/lib/action_mcp/json_rpc/json_rpc_error.rb

@@ -2,6 +2,7 @@
 
 module ActionMCP
   module JsonRpc
+    # Custom exception class for JSON-RPC errors, based on the JSON-RPC 2.0 specification.
     class JsonRpcError < StandardError
       # Define the standard JSON-RPC 2.0 error codes
       ERROR_CODES = {
@@ -31,14 +32,25 @@ module ActionMCP
         }
       }.freeze
 
+      # @return [Integer] The error code.
+      # @return [Object] The error data.
       attr_reader :code, :data
 
       # Retrieve error details by symbol.
+      #
+      # @param symbol [Symbol] The error symbol.
+      # @raise [ArgumentError] if the error code is unknown.
+      # @return [Hash] The error details.
       def self.[](symbol)
         ERROR_CODES[symbol] or raise ArgumentError, "Unknown error code: #{symbol}"
       end
 
       # Build an error hash, allowing custom message or data to override defaults.
+      #
+      # @param symbol [Symbol] The error symbol.
+      # @param message [String, nil] Optional custom message.
+      # @param data [Object, nil] Optional custom data.
+      # @return [Hash] The error hash.
       def self.build(symbol, message: nil, data: nil)
         error = self[symbol].dup
         error[:message] = message if message
@@ -47,6 +59,10 @@ module ActionMCP
       end
 
       # Initialize the error using a symbol key, with optional custom message and data.
+      #
+      # @param symbol [Symbol] The error symbol.
+      # @param message [String, nil] Optional custom message.
+      # @param data [Object, nil] Optional custom data.
       def initialize(symbol, message: nil, data: nil)
         error_details = self.class.build(symbol, message: message, data: data)
         @code = error_details[:code]
@@ -55,6 +71,8 @@ module ActionMCP
       end
 
       # Returns a hash formatted for a JSON-RPC error response.
+      #
+      # @return [Hash] The error hash.
       def as_json
         hash = { code: code, message: message }
         hash[:data] = data if data
@@ -62,6 +80,9 @@ module ActionMCP
       end
 
       # Converts the error hash to a JSON string.
+      #
+      # @param _args [Array] Arguments passed to MultiJson.dump.
+      # @return [String] The JSON string.
       def to_json(*_args)
         MultiJson.dump(as_json, *args)
       end

data/lib/action_mcp/json_rpc/notification.rb

@@ -2,11 +2,19 @@
 
 module ActionMCP
   module JsonRpc
+    # Represents a JSON-RPC notification.
     Notification = Data.define(:method, :params) do
+      # Initializes a new Notification.
+      #
+      # @param method [String] The method name.
+      # @param params [Hash, nil] The parameters (optional).
       def initialize(method:, params: nil)
         super
       end
 
+      # Returns a hash representation of the notification.
+      #
+      # @return [Hash] The hash representation.
       def to_h
         {
           jsonrpc: "2.0",

data/lib/action_mcp/json_rpc/request.rb

@@ -2,12 +2,22 @@
 
 module ActionMCP
   module JsonRpc
+    # Represents a JSON-RPC request.
     Request = Data.define(:id, :method, :params) do
+      # Initializes a new Request.
+      #
+      # @param id [String, Numeric] The request identifier.
+      # @param method [String] The method name.
+      # @param params [Hash, nil] The parameters (optional).
+      # @raise [JsonRpcError] if the ID is invalid.
       def initialize(id:, method:, params: nil)
         validate_id(id)
         super
       end
 
+      # Returns a hash representation of the request.
+      #
+      # @return [Hash] The hash representation.
       def to_h
         hash = {
           jsonrpc: "2.0",
@@ -20,6 +30,10 @@ module ActionMCP
 
       private
 
+      # Validates the ID.
+      #
+      # @param id [Object] The ID to validate.
+      # @raise [JsonRpcError] if the ID is invalid.
       def validate_id(id)
         unless id.is_a?(String) || id.is_a?(Numeric)
           raise JsonRpcError.new(:invalid_params,

data/lib/action_mcp/json_rpc/response.rb

@@ -2,14 +2,25 @@
 
 module ActionMCP
   module JsonRpc
+    # Represents a JSON-RPC response.
     Response = Data.define(:id, :result, :error) do
+      # Initializes a new Response.
+      #
+      # @param id [String, Numeric] The request identifier.
+      # @param result [Object, nil] The result data (optional).
+      # @param error [Object, nil] The error data (optional).
+      # @raise [ArgumentError] if neither result nor error is provided, or if both are provided.
       def initialize(id:, result: nil, error: nil)
         validate_presence_of_result_or_error!(result, error)
         validate_absence_of_both_result_and_error!(result, error)
+        result, error = transform_value_to_hash!(result, error)
 
-        super
+        super(id: id, result: result, error: error)
       end
 
+      # Returns a hash representation of the response.
+      #
+      # @return [Hash] The hash representation.
       def to_h
         {
           jsonrpc: "2.0",
@@ -19,15 +30,35 @@ module ActionMCP
         }.compact
       end
 
+      def is_error?
+        error.present?
+      end
+
       private
 
+      # Validates that either result or error is present.
+      #
+      # @param result [Object, nil] The result data.
+      # @param error [Object, nil] The error data.
+      # @raise [ArgumentError] if neither result nor error is provided.
       def validate_presence_of_result_or_error!(result, error)
         raise ArgumentError, "Either result or error must be provided." if result.nil? && error.nil?
       end
 
+      # Validates that both result and error are not present simultaneously.
+      #
+      # @param result [Object, nil] The result data.
+      # @param error [Object, nil] The error data.
+      # @raise [ArgumentError] if both result and error are provided.
       def validate_absence_of_both_result_and_error!(result, error)
         raise ArgumentError, "Both result and error cannot be provided simultaneously." if result && error
       end
+
+      def transform_value_to_hash!(result, error)
+        result = result.is_a?(String) ? (MultiJson.load(result) rescue result) : result
+        error = error.is_a?(String) ? (MultiJson.load(error) rescue error) : error
+        [ result, error ]
+      end
     end
   end
 end

data/lib/action_mcp/json_rpc.rb

@@ -1,12 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Module for handling JSON-RPC communication.
   module JsonRpc
-    extend ActiveSupport::Autoload
-
-    autoload :JsonRpcError
-    autoload :Notification
-    autoload :Request
-    autoload :Response
   end
 end

data/lib/action_mcp/json_rpc_handler.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class JsonRpcHandler
+    attr_reader :transport
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    # Process a single line of input.
+    def call(line)
+      request = if line.is_a?(String)
+                  line.strip!
+                  return if line.empty?
+                  begin
+                    MultiJson.load(line)
+                  rescue MultiJson::ParseError => e
+                    Rails.logger.error("Failed to parse JSON: #{e.message}")
+                    return
+                  end
+
+      else
+                  line
+      end
+      process_request(request)
+    end
+
+    private
+
+    def process_request(request)
+       unless request["jsonrpc"] == "2.0"
+         puts "Invalid request: #{request}"
+         return
+       end
+      method = request["method"]
+      id = request["id"]
+      params = request["params"]
+
+      case method
+      when "initialize"
+        puts "\e[31mSending capabilities\e[0m"
+        transport.send_capabilities(id, params)
+      when "ping"
+        transport.send_pong(id)
+      when /^notifications\//
+        puts "\e[31mProcessing notifications\e[0m"
+        process_notifications(method, id, params)
+      when /^prompts\//
+        process_prompts(method, id, params)
+      when /^resources\//
+        process_resources(method, id, params)
+      when /^tools\//
+        process_tools(method, id, params)
+      else
+        puts "\e[31mUnknown method: #{method}\e[0m"
+        Rails.logger.warn("Unknown method: #{method}")
+      end
+    end
+
+    def process_notifications(method, _id, _params)
+      case method
+      when "notifications/initialized"
+        puts "\e[31mInitialized\e[0m"
+        transport.initialized!
+      else
+        Rails.logger.warn("Unknown notifications method: #{method}")
+      end
+    end
+
+    def process_prompts(method, id, params)
+      case method
+      when "prompts/get"
+        transport.send_prompts_get(id, params&.dig("name"), params&.dig("arguments"))
+      when "prompts/list"
+        transport.send_prompts_list(id)
+      else
+        Rails.logger.warn("Unknown prompts method: #{method}")
+      end
+    end
+
+    def process_resources(method, id, params)
+      case method
+      when "resources/list"
+        transport.send_resources_list(id)
+      when "resources/templates/list"
+        transport.send_resource_templates_list(id)
+      when "resources/read"
+        transport.send_resource_read(id, params)
+      else
+        Rails.logger.warn("Unknown resources method: #{method}")
+      end
+    end
+
+    def process_tools(method, id, params)
+      case method
+      when "tools/list"
+        transport.send_tools_list(id)
+      when "tools/call"
+        transport.send_tools_call(id, params&.dig("name"), params&.dig("arguments"))
+      else
+        Rails.logger.warn("Unknown tools method: #{method}")
+      end
+    end
+  end
+end

data/lib/action_mcp/logging.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_support/tagged_logging"
+require "active_support/logger"
+require "logger"
+
+module ActionMCP
+  # Module for providing logging functionality to ActionMCP transport.
+  module Logging
+    extend ActiveSupport::Concern
+
+    # Included hook to configure the logger.
+    included do
+      logger_instance = ActiveSupport::Logger.new(STDOUT)
+      logger_instance.level = Logger.const_get(ActionMCP.configuration.logging_level.to_s.upcase)
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(logger_instance)
+    end
+  end
+end

data/lib/action_mcp/prompt.rb

@@ -2,66 +2,44 @@
 
 module ActionMCP
   # Abstract base class for Prompts
-  # Defines: name, description, arguments, plus auto-registration.
-  class Prompt
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-    include Renderable
-
-    class_attribute :_prompt_name, instance_accessor: false
-    class_attribute :_description, instance_accessor: false, default: ""
+  class Prompt < Capability
     class_attribute :_argument_definitions, instance_accessor: false, default: []
-    class_attribute :abstract_prompt, instance_accessor: false, default: false
-
-    def self.inherited(subclass)
-      super
-      return if subclass == Prompt
-      return if subclass.name == "ApplicationPrompt"
-
-      subclass.abstract_prompt = false
-
-      # Automatically register the subclass with the PromptsRegistry
-      PromptsRegistry.register(subclass.prompt_name, subclass)
-    end
-
-    def self.abstract!
-      self.abstract_prompt = true
-      # If already registered, you might want to unregister it here.
-    end
-
-    def self.abstract?
-      abstract_prompt
-    end
 
     # ---------------------------------------------------
     # Prompt Name
     # ---------------------------------------------------
+    # Gets or sets the prompt name.
+    #
+    # @param name [String, nil] The prompt name to set.
+    # @return [String] The prompt name.
     def self.prompt_name(name = nil)
       if name
-        self._prompt_name = name
+        self._capability_name = name
       else
-        _prompt_name || default_prompt_name
+        _capability_name || default_prompt_name
       end
     end
 
+    # Returns the default prompt name based on the class name.
+    #
+    # @return [String] The default prompt name.
     def self.default_prompt_name
-      name.demodulize.underscore.dasherize.sub(/-prompt$/, "")
+      name.demodulize.underscore.sub(/_prompt$/, "")
     end
-
-    # ---------------------------------------------------
-    # Description
-    # ---------------------------------------------------
-    def self.description(text = nil)
-      if text
-        self._description = text
-      else
-        _description
-      end
+    class << self
+    alias default_capability_name default_prompt_name
     end
 
     # ---------------------------------------------------
     # Argument DSL
     # ---------------------------------------------------
+    # Defines an argument for the prompt.
+    #
+    # @param arg_name [Symbol] The name of the argument.
+    # @param description [String] The description of the argument.
+    # @param required [Boolean] Whether the argument is required.
+    # @param default [Object] The default value of the argument.
+    # @return [void]
     def self.argument(arg_name, description: "", required: false, default: nil)
       arg_def = {
         name: arg_name.to_s,
@@ -78,6 +56,9 @@ module ActionMCP
       validates arg_name, presence: true
     end
 
+    # Returns the list of argument definitions.
+    #
+    # @return [Array<Hash>] The list of argument definitions.
     def self.arguments
       _argument_definitions
     end
@@ -85,6 +66,7 @@ module ActionMCP
     # ---------------------------------------------------
     # Convert prompt definition to Hash
     # ---------------------------------------------------
+    # @return [Hash] The prompt definition as a Hash.
     def self.to_h
       {
         name: prompt_name,
@@ -106,6 +88,8 @@ module ActionMCP
     # Raises:
     #   ActionMCP::JsonRpc::JsonRpcError(:invalid_params) if validation fails.
     #
+    # @param params [Hash] The parameters for the prompt.
+    # @return [Object] The result of the prompt's call method.
     def self.call(params)
       prompt = new(params) # Initialize an instance with provided params
       unless prompt.valid?
@@ -131,14 +115,14 @@ module ActionMCP
     #
     # Usage: Called internally after validation in self.call
     #
+    # @raise [NotImplementedError] Subclasses must implement the call method.
+    # @return [Array<Content>] Array of Content objects is expected as return value
     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.
-      #     # Return something meaningful.
-      #   end
+      #  # Perform logic, e.g. analyze code, etc.
+      #  # Return something meaningful.
     end
   end
 end

data/lib/action_mcp/prompts_registry.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Registry for managing prompts.
   class PromptsRegistry < RegistryBase
     class << self
+      # @!method prompts
+      #   Returns all registered prompts.
+      #   @return [Hash] A hash of registered prompts.
       alias prompts items
-      alias available_prompts enabled
 
+      # Calls a prompt with the given name and arguments.
+      #
+      # @param prompt_name [String] The name of the prompt to call.
+      # @param arguments [Hash] The arguments to pass to the prompt.
+      # @return [Hash] A hash containing the prompt's response.
       def prompt_call(prompt_name, arguments)
         prompt = find(prompt_name)
         prompt = prompt.new(arguments)
@@ -24,6 +32,10 @@ module ActionMCP
           }
         end
       end
+
+      def item_klass
+        Prompt
+      end
     end
   end
 end