actionmcp 0.2.0 → 0.2.3

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

data/lib/action_mcp/registry_base.rb

@@ -1,55 +1,61 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Base class for registries.
   class RegistryBase
+    # Error raised when an item is not found in the registry.
     class NotFound < StandardError; end
 
     class << self
+      # Returns all registered items.
+      #
+      # @return [Hash] A hash of registered items.
       def items
-        @items ||= {}
+        @items = item_klass.descendants.each_with_object({}) do |klass, hash|
+          next if klass.abstract?
+          hash[klass.capability_name] = klass
+        end
       end
 
-      # 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] = { klass: klass, enabled: true }
-      end
-
-      # Retrieve an item’s metadata by name.
+      # Retrieve an item by name.
+      #
+      # @param name [String] The name of the item to find.
+      # @raise [NotFound] if the item is not found.
+      # @return [Class] The class of the item.
       def find(name)
         item = items[name]
         raise NotFound, "Item '#{name}' not found." if item.nil?
 
-        item[:klass]
+        item
       end
 
       # Return the number of registered items, ignoring abstract ones.
+      #
+      # @return [Integer] The number of registered items.
       def size
-        items.values.reject { |item| abstract_item?(item) }.size
-      end
-
-      def unregister(name)
-        items.delete(name)
+        items.size
       end
 
-      def clear!
-        items.clear
-      end
-
-      # Chainable scope: returns only enabled, non-abstract items.
-      def enabled
+      # Chainable scope: returns only non-abstract items.
+      #
+      # @return [RegistryScope] A RegistryScope instance.
+      def non_abstract
         RegistryScope.new(items)
       end
 
       private
 
       # Helper to determine if an item is abstract.
-      def abstract_item?(item)
-        klass = item[:klass]
+      #
+      # @param klass [Class] The class to check.
+      # @return [Boolean] True if the class is abstract, false otherwise.
+      def abstract_item?(klass)
         klass.respond_to?(:abstract?) && klass.abstract?
       end
+
+      def item_klass
+        raise NotImplementedError, "Implement in subclass"
+      end
     end
 
     # Query object for chainable registry scopes.
@@ -59,22 +65,35 @@ module ActionMCP
       # Using a Data type for items.
       Item = Data.define(:name, :klass)
 
+      # Initializes a new RegistryScope instance.
+      #
+      # @param items [Hash] The items to scope.
+      # @return [void]
       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]) }
+        @items = items.reject do |_name, klass|
+          RegistryBase.send(:abstract_item?, klass)
+        end.map { |name, klass| Item.new(name, klass) }
       end
 
+      # Iterates over the items in the scope.
+      #
+      # @yield [Item] The item to yield.
+      # @return [void]
       def each(&)
         @items.each(&)
       end
 
-      # Returns the names (keys) of all enabled items.
+      # Returns the names (keys) of all non-abstract items.
+      #
+      # @return [Array<String>] The names of all non-abstract items.
       def keys
         @items.map(&:name)
       end
 
       # Chainable finder for available tools by name.
+      #
+      # @param name [String] The name of the tool to find.
+      # @return [Class, nil] The class of the tool, or nil if not found.
       def find_available_tool(name)
         item = @items.find { |i| i.name == name }
         item&.klass

data/lib/action_mcp/renderable.rb

@@ -1,23 +1,49 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Module for rendering content.
   module Renderable
+    # Renders text content.
+    #
+    # @param text [String] The text to render.
+    # @return [Content::Text] The rendered text content.
     def render_text(text)
       Content::Text.new(text)
     end
 
+    # Renders audio content.
+    #
+    # @param data [String] The audio data.
+    # @param mime_type [String] The MIME type of the audio data.
+    # @return [Content::Audio] The rendered audio content.
     def render_audio(data, mime_type)
       Content::Audio.new(data, mime_type)
     end
 
+    # Renders image content.
+    #
+    # @param data [String] The image data.
+    # @param mime_type [String] The MIME type of the image data.
+    # @return [Content::Image] The rendered image content.
     def render_image(data, mime_type)
       Content::Image.new(data, mime_type)
     end
 
+    # Renders a resource.
+    #
+    # @param uri [String] The URI of the resource.
+    # @param mime_type [String] The MIME type of the resource.
+    # @param text [String, nil] The text associated with the resource.
+    # @param blob [String, nil] The blob associated with the resource.
+    # @return [Content::Resource] The rendered resource content.
     def render_resource(uri, mime_type, text: nil, blob: nil)
       Content::Resource.new(uri, mime_type, text: text, blob: blob)
     end
 
+    # Renders an error.
+    #
+    # @param errors [Array<String>] The errors to render.
+    # @return [Hash] A hash containing the error information.
     def render_error(errors)
       {
         isError: true,

data/lib/action_mcp/resource.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Represents a resource with its metadata.
   Resource = Data.define(:uri, :name, :description, :mime_type, :size) do
     # Convert the resource to a hash with the keys expected by MCP.
     # Note: The key for mime_type is converted to 'mimeType' as specified.
+    #
+    # @return [Hash] A hash representation of the resource.
     def to_h
       hash = { uri: uri, name: name }
       hash[:description] = description if description
@@ -12,7 +15,6 @@ module ActionMCP
       hash
     end
 
-    # Convert the resource to a JSON string.
     def to_json(*)
       MultiJson.dump(to_h, *)
     end

data/lib/action_mcp/server.rb

@@ -1,7 +1,10 @@
-# frozen_string_literal: true
 
 # TODO: move all server related code here before version 1.0.0
 module ActionMCP
+  # Module for server-related functionality.
   module Server
+    module_function def server
+      @server ||= ActionCable::Server::Base.new
+    end
   end
 end

data/lib/action_mcp/string_array.rb

@@ -1,7 +1,12 @@
 # frozen_string_literal: true
 
 module ActionMCP
+  # Custom type for handling arrays of strings in ActiveModel.
   class StringArray < ActiveModel::Type::Value
+    # Casts the given value to an array of strings.
+    #
+    # @param value [Object] The value to cast.
+    # @return [Array<String>] The array of strings.
     def cast(value)
       Array(value).map(&:to_s) # Ensure all elements are strings
     end